blob: c29d1aa2c54f30a76c25aa6ba843008b567ca96f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/misc.c
3 *
Steve Frenchad7a2922008-02-07 23:25:02 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21
22#include <linux/slab.h>
23#include <linux/ctype.h>
24#include <linux/mempool.h>
25#include "cifspdu.h"
26#include "cifsglob.h"
27#include "cifsproto.h"
28#include "cifs_debug.h"
29#include "smberr.h"
30#include "nterr.h"
Steve French6c91d362005-04-28 22:41:06 -070031#include "cifs_unicode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33extern mempool_t *cifs_sm_req_poolp;
34extern mempool_t *cifs_req_poolp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Steve Frenchfb8c4b12007-07-10 01:16:18 +000036/* The xid serves as a useful identifier for each incoming vfs request,
37 in a similar way to the mid which is useful to track each sent smb,
38 and CurrentXid can also provide a running counter (although it
39 will eventually wrap past zero) of the total vfs operations handled
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 since the cifs fs was mounted */
41
42unsigned int
43_GetXid(void)
44{
45 unsigned int xid;
46
47 spin_lock(&GlobalMid_Lock);
48 GlobalTotalActiveXid++;
Steve French50c2f752007-07-13 00:33:32 +000049
50 /* keep high water mark for number of simultaneous ops in filesystem */
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 if (GlobalTotalActiveXid > GlobalMaxActiveXid)
Steve French50c2f752007-07-13 00:33:32 +000052 GlobalMaxActiveXid = GlobalTotalActiveXid;
Steve French790fe572007-07-07 19:25:05 +000053 if (GlobalTotalActiveXid > 65000)
Joe Perchesb6b38f72010-04-21 03:50:45 +000054 cFYI(1, "warning: more than 65000 requests active");
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 xid = GlobalCurrentXid++;
56 spin_unlock(&GlobalMid_Lock);
57 return xid;
58}
59
60void
61_FreeXid(unsigned int xid)
62{
63 spin_lock(&GlobalMid_Lock);
Steve French790fe572007-07-07 19:25:05 +000064 /* if (GlobalTotalActiveXid == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 BUG(); */
66 GlobalTotalActiveXid--;
67 spin_unlock(&GlobalMid_Lock);
68}
69
Steve French96daf2b2011-05-27 04:34:02 +000070struct cifs_ses *
Linus Torvalds1da177e2005-04-16 15:20:36 -070071sesInfoAlloc(void)
72{
Steve French96daf2b2011-05-27 04:34:02 +000073 struct cifs_ses *ret_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Steve French96daf2b2011-05-27 04:34:02 +000075 ret_buf = kzalloc(sizeof(struct cifs_ses), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 if (ret_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 atomic_inc(&sesInfoAllocCount);
78 ret_buf->status = CifsNew;
Jeff Layton14fbf502008-11-14 13:53:46 -050079 ++ret_buf->ses_count;
80 INIT_LIST_HEAD(&ret_buf->smb_ses_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -050081 INIT_LIST_HEAD(&ret_buf->tcon_list);
Steve Frenchd7b619c2010-02-25 05:36:46 +000082 mutex_init(&ret_buf->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 }
84 return ret_buf;
85}
86
87void
Steve French96daf2b2011-05-27 04:34:02 +000088sesInfoFree(struct cifs_ses *buf_to_free)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
90 if (buf_to_free == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +000091 cFYI(1, "Null buffer passed to sesInfoFree");
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 return;
93 }
94
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 atomic_dec(&sesInfoAllocCount);
Jesper Juhlf99d49a2005-11-07 01:01:34 -080096 kfree(buf_to_free->serverOS);
97 kfree(buf_to_free->serverDomain);
98 kfree(buf_to_free->serverNOS);
Jeff Layton55162de2008-12-05 20:41:21 -050099 if (buf_to_free->password) {
100 memset(buf_to_free->password, 0, strlen(buf_to_free->password));
101 kfree(buf_to_free->password);
102 }
Steve French8727c8a2011-02-25 01:11:56 -0600103 kfree(buf_to_free->user_name);
Steve French39798772006-05-31 22:40:51 +0000104 kfree(buf_to_free->domainName);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 kfree(buf_to_free);
106}
107
Steve French96daf2b2011-05-27 04:34:02 +0000108struct cifs_tcon *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109tconInfoAlloc(void)
110{
Steve French96daf2b2011-05-27 04:34:02 +0000111 struct cifs_tcon *ret_buf;
112 ret_buf = kzalloc(sizeof(struct cifs_tcon), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 if (ret_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 atomic_inc(&tconInfoAllocCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 ret_buf->tidStatus = CifsNew;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500116 ++ret_buf->tc_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 INIT_LIST_HEAD(&ret_buf->openFileList);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500118 INIT_LIST_HEAD(&ret_buf->tcon_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#ifdef CONFIG_CIFS_STATS
120 spin_lock_init(&ret_buf->stat_lock);
121#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 }
123 return ret_buf;
124}
125
126void
Steve French96daf2b2011-05-27 04:34:02 +0000127tconInfoFree(struct cifs_tcon *buf_to_free)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
129 if (buf_to_free == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000130 cFYI(1, "Null buffer passed to tconInfoFree");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 return;
132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 atomic_dec(&tconInfoAllocCount);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800134 kfree(buf_to_free->nativeFileSystem);
Jeff Layton00e485b2008-12-05 20:41:21 -0500135 if (buf_to_free->password) {
136 memset(buf_to_free->password, 0, strlen(buf_to_free->password));
137 kfree(buf_to_free->password);
138 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 kfree(buf_to_free);
140}
141
142struct smb_hdr *
143cifs_buf_get(void)
144{
145 struct smb_hdr *ret_buf = NULL;
146
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000147/* We could use negotiated size instead of max_msgsize -
148 but it may be more efficient to always alloc same size
149 albeit slightly larger than necessary and maxbuffersize
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 defaults to this and can not be bigger */
Pekka Enberg232087c2008-09-15 13:22:54 +0300151 ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 /* clear the first few header bytes */
154 /* for most paths, more is cleared in header_assemble */
155 if (ret_buf) {
156 memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
157 atomic_inc(&bufAllocCount);
Steve French4498eed2005-12-03 13:58:57 -0800158#ifdef CONFIG_CIFS_STATS2
159 atomic_inc(&totBufAllocCount);
160#endif /* CONFIG_CIFS_STATS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 }
162
163 return ret_buf;
164}
165
166void
167cifs_buf_release(void *buf_to_free)
168{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 if (buf_to_free == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000170 /* cFYI(1, "Null buffer passed to cifs_buf_release");*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return;
172 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000173 mempool_free(buf_to_free, cifs_req_poolp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175 atomic_dec(&bufAllocCount);
176 return;
177}
178
179struct smb_hdr *
180cifs_small_buf_get(void)
181{
182 struct smb_hdr *ret_buf = NULL;
183
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000184/* We could use negotiated size instead of max_msgsize -
185 but it may be more efficient to always alloc same size
186 albeit slightly larger than necessary and maxbuffersize
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 defaults to this and can not be bigger */
Pekka Enberg232087c2008-09-15 13:22:54 +0300188 ret_buf = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 if (ret_buf) {
190 /* No need to clear memory here, cleared in header assemble */
191 /* memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
192 atomic_inc(&smBufAllocCount);
Steve French4498eed2005-12-03 13:58:57 -0800193#ifdef CONFIG_CIFS_STATS2
194 atomic_inc(&totSmBufAllocCount);
195#endif /* CONFIG_CIFS_STATS2 */
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
198 return ret_buf;
199}
200
201void
202cifs_small_buf_release(void *buf_to_free)
203{
204
205 if (buf_to_free == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000206 cFYI(1, "Null buffer passed to cifs_small_buf_release");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 return;
208 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000209 mempool_free(buf_to_free, cifs_sm_req_poolp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 atomic_dec(&smBufAllocCount);
212 return;
213}
214
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000215/*
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400216 * Find a free multiplex id (SMB mid). Otherwise there could be
217 * mid collisions which might cause problems, demultiplexing the
218 * wrong response to this request. Multiplex ids could collide if
219 * one of a series requests takes much longer than the others, or
220 * if a very large number of long lived requests (byte range
221 * locks or FindNotify requests) are pending. No more than
222 * 64K-1 requests can be outstanding at one time. If no
223 * mids are available, return zero. A future optimization
224 * could make the combination of mids and uid the key we use
225 * to demultiplex on (rather than mid alone).
226 * In addition to the above check, the cifs demultiplex
227 * code already used the command code as a secondary
228 * check of the frame and if signing is negotiated the
229 * response would be discarded if the mid were the same
230 * but the signature was wrong. Since the mid is not put in the
231 * pending queue until later (when it is about to be dispatched)
232 * we do have to limit the number of outstanding requests
233 * to somewhat less than 64K-1 although it is hard to imagine
234 * so many threads being in the vfs at one time.
235 */
236__u64 GetNextMid(struct TCP_Server_Info *server)
Steve French1982c342005-08-17 12:38:22 -0700237{
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400238 __u64 mid = 0;
239 __u16 last_mid, cur_mid;
Jeff Layton92a4e0f2011-01-29 07:02:28 -0500240 bool collision;
Steve French1982c342005-08-17 12:38:22 -0700241
242 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400243
244 /* mid is 16 bit only for CIFS/SMB */
245 cur_mid = (__u16)((server->CurrentMid) & 0xffff);
246 /* we do not want to loop forever */
247 last_mid = cur_mid;
248 cur_mid++;
249
250 /*
251 * This nested loop looks more expensive than it is.
252 * In practice the list of pending requests is short,
253 * fewer than 50, and the mids are likely to be unique
254 * on the first pass through the loop unless some request
255 * takes longer than the 64 thousand requests before it
256 * (and it would also have to have been a request that
257 * did not time out).
258 */
259 while (cur_mid != last_mid) {
Steve French1982c342005-08-17 12:38:22 -0700260 struct mid_q_entry *mid_entry;
Jeff Layton92a4e0f2011-01-29 07:02:28 -0500261 unsigned int num_mids;
Steve French1982c342005-08-17 12:38:22 -0700262
Jeff Layton92a4e0f2011-01-29 07:02:28 -0500263 collision = false;
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400264 if (cur_mid == 0)
265 cur_mid++;
Steve French1982c342005-08-17 12:38:22 -0700266
Jeff Layton92a4e0f2011-01-29 07:02:28 -0500267 num_mids = 0;
268 list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
269 ++num_mids;
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400270 if (mid_entry->mid == cur_mid &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400271 mid_entry->mid_state == MID_REQUEST_SUBMITTED) {
Steve French1982c342005-08-17 12:38:22 -0700272 /* This mid is in use, try a different one */
Jeff Layton92a4e0f2011-01-29 07:02:28 -0500273 collision = true;
Steve French1982c342005-08-17 12:38:22 -0700274 break;
275 }
276 }
Jeff Layton92a4e0f2011-01-29 07:02:28 -0500277
278 /*
279 * if we have more than 32k mids in the list, then something
280 * is very wrong. Possibly a local user is trying to DoS the
281 * box by issuing long-running calls and SIGKILL'ing them. If
282 * we get to 2^16 mids then we're in big trouble as this
283 * function could loop forever.
284 *
285 * Go ahead and assign out the mid in this situation, but force
286 * an eventual reconnect to clean out the pending_mid_q.
287 */
288 if (num_mids > 32768)
289 server->tcpStatus = CifsNeedReconnect;
290
291 if (!collision) {
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400292 mid = (__u64)cur_mid;
293 server->CurrentMid = mid;
Steve French1982c342005-08-17 12:38:22 -0700294 break;
295 }
Pavel Shilovsky243d04b2012-03-23 14:28:03 -0400296 cur_mid++;
Steve French1982c342005-08-17 12:38:22 -0700297 }
298 spin_unlock(&GlobalMid_Lock);
299 return mid;
300}
301
302/* NB: MID can not be set if treeCon not passed in, in that
303 case it is responsbility of caller to set the mid */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304void
305header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
Steve French96daf2b2011-05-27 04:34:02 +0000306 const struct cifs_tcon *treeCon, int word_count
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 /* length of fixed section (word count) in two byte units */)
308{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000309 struct list_head *temp_item;
Steve French96daf2b2011-05-27 04:34:02 +0000310 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 char *temp = (char *) buffer;
312
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000313 memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000315 buffer->smb_buf_length = cpu_to_be32(
Steve French630f3f02007-10-25 21:17:17 +0000316 (2 * word_count) + sizeof(struct smb_hdr) -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 4 /* RFC 1001 length field does not count */ +
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000318 2 /* for bcc field itself */) ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 buffer->Protocol[0] = 0xFF;
321 buffer->Protocol[1] = 'S';
322 buffer->Protocol[2] = 'M';
323 buffer->Protocol[3] = 'B';
324 buffer->Command = smb_command;
325 buffer->Flags = 0x00; /* case sensitive */
326 buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
327 buffer->Pid = cpu_to_le16((__u16)current->tgid);
328 buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 if (treeCon) {
330 buffer->Tid = treeCon->tid;
331 if (treeCon->ses) {
332 if (treeCon->ses->capabilities & CAP_UNICODE)
333 buffer->Flags2 |= SMBFLG2_UNICODE;
Steve Frenchad7a2922008-02-07 23:25:02 +0000334 if (treeCon->ses->capabilities & CAP_STATUS32)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
Steve Frenchad7a2922008-02-07 23:25:02 +0000336
Steve French1982c342005-08-17 12:38:22 -0700337 /* Uid is not converted */
338 buffer->Uid = treeCon->ses->Suid;
339 buffer->Mid = GetNextMid(treeCon->ses->server);
Steve French790fe572007-07-07 19:25:05 +0000340 if (multiuser_mount != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 /* For the multiuser case, there are few obvious technically */
342 /* possible mechanisms to match the local linux user (uid) */
343 /* to a valid remote smb user (smb_uid): */
344 /* 1) Query Winbind (or other local pam/nss daemon */
345 /* for userid/password/logon_domain or credential */
346 /* 2) Query Winbind for uid to sid to username mapping */
347 /* and see if we have a matching password for existing*/
348 /* session for that user perhas getting password by */
349 /* adding a new pam_cifs module that stores passwords */
350 /* so that the cifs vfs can get at that for all logged*/
351 /* on users */
352 /* 3) (Which is the mechanism we have chosen) */
353 /* Search through sessions to the same server for a */
354 /* a match on the uid that was passed in on mount */
355 /* with the current processes uid (or euid?) and use */
356 /* that smb uid. If no existing smb session for */
357 /* that uid found, use the default smb session ie */
358 /* the smb session for the volume mounted which is */
359 /* the same as would be used if the multiuser mount */
360 /* flag were disabled. */
361
362 /* BB Add support for establishing new tCon and SMB Session */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000363 /* with userid/password pairs found on the smb session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 /* for other target tcp/ip addresses BB */
David Howellsa001e5b2008-11-14 10:38:47 +1100365 if (current_fsuid() != treeCon->ses->linux_uid) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000366 cFYI(1, "Multiuser mode and UID "
367 "did not match tcon uid");
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530368 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500369 list_for_each(temp_item, &treeCon->ses->server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000370 ses = list_entry(temp_item, struct cifs_ses, smb_ses_list);
David Howellsa001e5b2008-11-14 10:38:47 +1100371 if (ses->linux_uid == current_fsuid()) {
Steve French790fe572007-07-07 19:25:05 +0000372 if (ses->server == treeCon->ses->server) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000373 cFYI(1, "found matching uid substitute right smb_uid");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 buffer->Uid = ses->Suid;
375 break;
376 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000377 /* BB eventually call cifs_setup_session here */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000378 cFYI(1, "local UID found but no smb sess with this server exists");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
380 }
381 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530382 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 }
384 }
385 }
386 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
387 buffer->Flags2 |= SMBFLG2_DFS;
Steve Frenchd3485d32005-08-19 11:04:29 -0700388 if (treeCon->nocase)
389 buffer->Flags |= SMBFLG_CASELESS;
Steve French790fe572007-07-07 19:25:05 +0000390 if ((treeCon->ses) && (treeCon->ses->server))
Steve French96daf2b2011-05-27 04:34:02 +0000391 if (treeCon->ses->server->sec_mode &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
393 buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
394 }
395
396/* endian conversion of flags is now done just before sending */
397 buffer->WordCount = (char) word_count;
398 return;
399}
400
Steve French2cd646a2006-09-28 19:43:08 +0000401static int
Jeff Layton68abaff2011-01-28 15:05:42 -0500402check_smb_hdr(struct smb_hdr *smb, __u16 mid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
Jeff Layton68abaff2011-01-28 15:05:42 -0500404 /* does it have the right SMB "signature" ? */
405 if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff)) {
406 cERROR(1, "Bad protocol string signature header 0x%x",
407 *(unsigned int *)smb->Protocol);
408 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 }
Jeff Layton68abaff2011-01-28 15:05:42 -0500410
411 /* Make sure that message ids match */
412 if (mid != smb->Mid) {
413 cERROR(1, "Mids do not match. received=%u expected=%u",
414 smb->Mid, mid);
415 return 1;
416 }
417
418 /* if it's a response then accept */
419 if (smb->Flags & SMBFLG_RESPONSE)
420 return 0;
421
422 /* only one valid case where server sends us request */
423 if (smb->Command == SMB_COM_LOCKING_ANDX)
424 return 0;
425
426 cERROR(1, "Server sent request, not response. mid=%u", smb->Mid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return 1;
428}
429
430int
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400431checkSMB(char *buf, unsigned int total_read)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400433 struct smb_hdr *smb = (struct smb_hdr *)buf;
434 __u16 mid = smb->Mid;
Jeff Layton376b43f2011-10-11 06:41:32 -0400435 __u32 rfclen = be32_to_cpu(smb->smb_buf_length);
Steve French190fdeb2005-10-10 11:48:26 -0700436 __u32 clc_len; /* calculated length */
Jeff Layton376b43f2011-10-11 06:41:32 -0400437 cFYI(0, "checkSMB Length: 0x%x, smb_buf_length: 0x%x",
438 total_read, rfclen);
Steve Frenchd103e162006-10-12 17:49:24 +0000439
Jeff Layton376b43f2011-10-11 06:41:32 -0400440 /* is this frame too small to even get to a BCC? */
441 if (total_read < 2 + sizeof(struct smb_hdr)) {
442 if ((total_read >= sizeof(struct smb_hdr) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 && (smb->Status.CifsError != 0)) {
Jeff Layton376b43f2011-10-11 06:41:32 -0400444 /* it's an error return */
Steve Frenchd103e162006-10-12 17:49:24 +0000445 smb->WordCount = 0;
446 /* some error cases do not return wct and bcc */
447 return 0;
Jeff Layton376b43f2011-10-11 06:41:32 -0400448 } else if ((total_read == sizeof(struct smb_hdr) + 1) &&
Steve Frenchd103e162006-10-12 17:49:24 +0000449 (smb->WordCount == 0)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000450 char *tmp = (char *)smb;
Steve Frenchd103e162006-10-12 17:49:24 +0000451 /* Need to work around a bug in two servers here */
452 /* First, check if the part of bcc they sent was zero */
453 if (tmp[sizeof(struct smb_hdr)] == 0) {
454 /* some servers return only half of bcc
455 * on simple responses (wct, bcc both zero)
456 * in particular have seen this on
457 * ulogoffX and FindClose. This leaves
458 * one byte of bcc potentially unitialized
459 */
460 /* zero rest of bcc */
461 tmp[sizeof(struct smb_hdr)+1] = 0;
Steve French46c79a62006-03-02 00:07:08 +0000462 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000464 cERROR(1, "rcvd invalid byte count (bcc)");
Steve Frenchd103e162006-10-12 17:49:24 +0000465 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000466 cERROR(1, "Length less than smb header size");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 }
Jeff Layton376b43f2011-10-11 06:41:32 -0400468 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
470
Jeff Layton376b43f2011-10-11 06:41:32 -0400471 /* otherwise, there is enough to get to the BCC */
Jeff Layton68abaff2011-01-28 15:05:42 -0500472 if (check_smb_hdr(smb, mid))
Jeff Layton376b43f2011-10-11 06:41:32 -0400473 return -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -0400474 clc_len = smbCalcSize(smb);
Steve French184ed212006-02-24 06:15:11 +0000475
Jeff Layton376b43f2011-10-11 06:41:32 -0400476 if (4 + rfclen != total_read) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000477 cERROR(1, "Length read does not match RFC1001 length %d",
Jeff Layton376b43f2011-10-11 06:41:32 -0400478 rfclen);
479 return -EIO;
Steve French184ed212006-02-24 06:15:11 +0000480 }
481
Jeff Layton376b43f2011-10-11 06:41:32 -0400482 if (4 + rfclen != clc_len) {
Steve French184ed212006-02-24 06:15:11 +0000483 /* check if bcc wrapped around for large read responses */
Jeff Layton376b43f2011-10-11 06:41:32 -0400484 if ((rfclen > 64 * 1024) && (rfclen > clc_len)) {
Steve French184ed212006-02-24 06:15:11 +0000485 /* check if lengths match mod 64K */
Jeff Layton376b43f2011-10-11 06:41:32 -0400486 if (((4 + rfclen) & 0xFFFF) == (clc_len & 0xFFFF))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000487 return 0; /* bcc wrapped */
Steve French184ed212006-02-24 06:15:11 +0000488 }
Jeff Layton62846442011-01-31 09:14:17 -0500489 cFYI(1, "Calculated size %u vs length %u mismatch for mid=%u",
Jeff Layton376b43f2011-10-11 06:41:32 -0400490 clc_len, 4 + rfclen, smb->Mid);
Jeff Layton62846442011-01-31 09:14:17 -0500491
Jeff Layton376b43f2011-10-11 06:41:32 -0400492 if (4 + rfclen < clc_len) {
Jeff Layton62846442011-01-31 09:14:17 -0500493 cERROR(1, "RFC1001 size %u smaller than SMB for mid=%u",
Jeff Layton376b43f2011-10-11 06:41:32 -0400494 rfclen, smb->Mid);
495 return -EIO;
496 } else if (rfclen > clc_len + 512) {
Jeff Layton62846442011-01-31 09:14:17 -0500497 /*
498 * Some servers (Windows XP in particular) send more
499 * data than the lengths in the SMB packet would
500 * indicate on certain calls (byte range locks and
501 * trans2 find first calls in particular). While the
502 * client can handle such a frame by ignoring the
503 * trailing data, we choose limit the amount of extra
504 * data to 512 bytes.
505 */
506 cERROR(1, "RFC1001 size %u more than 512 bytes larger "
Jeff Layton376b43f2011-10-11 06:41:32 -0400507 "than SMB for mid=%u", rfclen, smb->Mid);
508 return -EIO;
Steve French46c79a62006-03-02 00:07:08 +0000509 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 }
Steve French20962432005-09-21 22:05:57 -0700511 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512}
Steve French4b18f2a2008-04-29 00:06:05 +0000513
514bool
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400515is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000516{
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400517 struct smb_hdr *buf = (struct smb_hdr *)buffer;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000518 struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500519 struct list_head *tmp, *tmp1, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000520 struct cifs_ses *ses;
521 struct cifs_tcon *tcon;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500522 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 struct cifsFileInfo *netfile;
524
Joe Perchesb6b38f72010-04-21 03:50:45 +0000525 cFYI(1, "Checking for oplock break or dnotify response");
Steve French790fe572007-07-07 19:25:05 +0000526 if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000528 struct smb_com_transaction_change_notify_rsp *pSMBr =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 (struct smb_com_transaction_change_notify_rsp *)buf;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000530 struct file_notify_information *pnotify;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 __u32 data_offset = 0;
Jeff Layton820a8032011-05-04 08:05:26 -0400532 if (get_bcc(buf) > sizeof(struct file_notify_information)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 data_offset = le32_to_cpu(pSMBr->DataOffset);
534
Steve French39798772006-05-31 22:40:51 +0000535 pnotify = (struct file_notify_information *)
536 ((char *)&pSMBr->hdr.Protocol + data_offset);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000537 cFYI(1, "dnotify on %s Action: 0x%x",
538 pnotify->FileName, pnotify->Action);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000539 /* cifs_dump_mem("Rcvd notify Data: ",buf,
Steve French39798772006-05-31 22:40:51 +0000540 sizeof(struct smb_hdr)+60); */
Steve French4b18f2a2008-04-29 00:06:05 +0000541 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
Steve French790fe572007-07-07 19:25:05 +0000543 if (pSMBr->hdr.Status.CifsError) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000544 cFYI(1, "notify err 0x%d",
545 pSMBr->hdr.Status.CifsError);
Steve French4b18f2a2008-04-29 00:06:05 +0000546 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 }
Steve French4b18f2a2008-04-29 00:06:05 +0000548 return false;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000549 }
Steve French790fe572007-07-07 19:25:05 +0000550 if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
Steve French4b18f2a2008-04-29 00:06:05 +0000551 return false;
Steve French790fe572007-07-07 19:25:05 +0000552 if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* no sense logging error on invalid handle on oplock
554 break - harmless race between close request and oplock
555 break response is expected from time to time writing out
556 large dirty files cached on the client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000557 if ((NT_STATUS_INVALID_HANDLE) ==
558 le32_to_cpu(pSMB->hdr.Status.CifsError)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000559 cFYI(1, "invalid handle on oplock break");
Steve French4b18f2a2008-04-29 00:06:05 +0000560 return true;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000561 } else if (ERRbadfid ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
Steve French4b18f2a2008-04-29 00:06:05 +0000563 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000565 return false; /* on valid oplock brk we get "request" */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
567 }
Steve French790fe572007-07-07 19:25:05 +0000568 if (pSMB->hdr.WordCount != 8)
Steve French4b18f2a2008-04-29 00:06:05 +0000569 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Joe Perchesb6b38f72010-04-21 03:50:45 +0000571 cFYI(1, "oplock type 0x%d level 0x%d",
572 pSMB->LockType, pSMB->OplockLevel);
Steve French790fe572007-07-07 19:25:05 +0000573 if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
Steve French4b18f2a2008-04-29 00:06:05 +0000574 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 /* look up tcon based on tid & uid */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530577 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500578 list_for_each(tmp, &srv->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000579 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500580 list_for_each(tmp1, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000581 tcon = list_entry(tmp1, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500582 if (tcon->tid != buf->Tid)
583 continue;
584
Steve Frencha4544342005-08-24 13:59:35 -0700585 cifs_stats_inc(&tcon->num_oplock_brks);
Jeff Layton44772882010-10-15 15:34:03 -0400586 spin_lock(&cifs_file_list_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500587 list_for_each(tmp2, &tcon->openFileList) {
588 netfile = list_entry(tmp2, struct cifsFileInfo,
Steve French57337e42005-04-28 22:41:10 -0700589 tlist);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500590 if (pSMB->Fid != netfile->netfid)
591 continue;
592
Joe Perchesb6b38f72010-04-21 03:50:45 +0000593 cFYI(1, "file id match, oplock break");
Jeff Laytona5e18bc2010-10-11 15:07:18 -0400594 pCifsInode = CIFS_I(netfile->dentry->d_inode);
Tejun Heo9b646972010-07-20 22:09:02 +0200595
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300596 cifs_set_oplock_level(pCifsInode,
Pavel Shilovsky12fed002011-01-17 20:15:44 +0300597 pSMB->OplockLevel ? OPLOCK_READ : 0);
Jeff Laytonda472fc2012-03-23 14:40:53 -0400598 queue_work(cifsiod_wq,
Jeff Laytonad635942011-07-26 12:20:17 -0400599 &netfile->oplock_break);
Tejun Heo9b646972010-07-20 22:09:02 +0200600 netfile->oplock_break_cancelled = false;
601
Jeff Layton44772882010-10-15 15:34:03 -0400602 spin_unlock(&cifs_file_list_lock);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530603 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500604 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 }
Jeff Layton44772882010-10-15 15:34:03 -0400606 spin_unlock(&cifs_file_list_lock);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530607 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000608 cFYI(1, "No matching file for oplock break");
Steve French4b18f2a2008-04-29 00:06:05 +0000609 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 }
611 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530612 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000613 cFYI(1, "Can not process oplock break for non-existent connection");
Steve French4b18f2a2008-04-29 00:06:05 +0000614 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615}
616
617void
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400618dump_smb(void *buf, int smb_buf_length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619{
620 int i, j;
621 char debug_line[17];
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400622 unsigned char *buffer = buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
624 if (traceSMB == 0)
625 return;
626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
Steve Frenchad7a2922008-02-07 23:25:02 +0000628 if (i % 8 == 0) {
629 /* have reached the beginning of line */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 printk(KERN_DEBUG "| ");
631 j = 0;
632 }
633 printk("%0#4x ", buffer[i]);
634 debug_line[2 * j] = ' ';
635 if (isprint(buffer[i]))
636 debug_line[1 + (2 * j)] = buffer[i];
637 else
638 debug_line[1 + (2 * j)] = '_';
639
Steve Frenchad7a2922008-02-07 23:25:02 +0000640 if (i % 8 == 7) {
641 /* reached end of line, time to print ascii */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 debug_line[16] = 0;
643 printk(" | %s\n", debug_line);
644 }
645 }
646 for (; j < 8; j++) {
647 printk(" ");
648 debug_line[2 * j] = ' ';
649 debug_line[1 + (2 * j)] = ' ';
650 }
Steve Frenchad7a2922008-02-07 23:25:02 +0000651 printk(" | %s\n", debug_line);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 return;
653}
Steve French6a0b4822005-04-28 22:41:05 -0700654
Jeff Laytonec06aed2009-11-06 14:18:29 -0500655void
656cifs_autodisable_serverino(struct cifs_sb_info *cifs_sb)
657{
658 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Suresh Jayaramanf534dc92009-11-16 12:03:16 +0530659 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000660 cERROR(1, "Autodisabling the use of server inode numbers on "
Jeff Laytonec06aed2009-11-06 14:18:29 -0500661 "%s. This server doesn't seem to support them "
662 "properly. Hardlinks will not be recognized on this "
663 "mount. Consider mounting with the \"noserverino\" "
664 "option to silence this message.",
Jeff Layton0d424ad2010-09-20 16:01:35 -0700665 cifs_sb_master_tcon(cifs_sb)->treeName);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500666 }
667}
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300668
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300669void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300670{
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300671 oplock &= 0xF;
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300672
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300673 if (oplock == OPLOCK_EXCLUSIVE) {
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300674 cinode->clientCanCacheAll = true;
675 cinode->clientCanCacheRead = true;
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300676 cFYI(1, "Exclusive Oplock granted on inode %p",
677 &cinode->vfs_inode);
678 } else if (oplock == OPLOCK_READ) {
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300679 cinode->clientCanCacheAll = false;
680 cinode->clientCanCacheRead = true;
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300681 cFYI(1, "Level II Oplock granted on inode %p",
682 &cinode->vfs_inode);
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300683 } else {
684 cinode->clientCanCacheAll = false;
685 cinode->clientCanCacheRead = false;
686 }
687}
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500688
689bool
690backup_cred(struct cifs_sb_info *cifs_sb)
691{
692 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID) {
693 if (cifs_sb->mnt_backupuid == current_fsuid())
694 return true;
695 }
696 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID) {
697 if (in_group_p(cifs_sb->mnt_backupgid))
698 return true;
699 }
700
701 return false;
702}
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400703
704void
705cifs_add_credits(struct TCP_Server_Info *server, const unsigned int add)
706{
707 spin_lock(&server->req_lock);
708 server->credits += add;
709 server->in_flight--;
710 spin_unlock(&server->req_lock);
711 wake_up(&server->request_q);
712}
713
714void
715cifs_set_credits(struct TCP_Server_Info *server, const int val)
716{
717 spin_lock(&server->req_lock);
718 server->credits = val;
719 server->oplocks = val > 1 ? enable_oplocks : false;
720 spin_unlock(&server->req_lock);
721}