blob: 19cc294c7c70b5de4b96f193642df5487648a5e4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/misc.c
3 *
Steve French83451872005-12-01 17:12:59 -08004 * Copyright (C) International Business Machines Corp., 2002,2005
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
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
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;
35extern struct task_struct * oplockThread;
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037/* The xid serves as a useful identifier for each incoming vfs request,
38 in a similar way to the mid which is useful to track each sent smb,
39 and CurrentXid can also provide a running counter (although it
40 will eventually wrap past zero) of the total vfs operations handled
41 since the cifs fs was mounted */
42
43unsigned int
44_GetXid(void)
45{
46 unsigned int xid;
47
48 spin_lock(&GlobalMid_Lock);
49 GlobalTotalActiveXid++;
50 if (GlobalTotalActiveXid > GlobalMaxActiveXid)
51 GlobalMaxActiveXid = GlobalTotalActiveXid; /* keep high water mark for number of simultaneous vfs ops in our filesystem */
Steve French1982c342005-08-17 12:38:22 -070052 if(GlobalTotalActiveXid > 65000)
53 cFYI(1,("warning: more than 65000 requests active"));
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 xid = GlobalCurrentXid++;
55 spin_unlock(&GlobalMid_Lock);
56 return xid;
57}
58
59void
60_FreeXid(unsigned int xid)
61{
62 spin_lock(&GlobalMid_Lock);
63 /* if(GlobalTotalActiveXid == 0)
64 BUG(); */
65 GlobalTotalActiveXid--;
66 spin_unlock(&GlobalMid_Lock);
67}
68
69struct cifsSesInfo *
70sesInfoAlloc(void)
71{
72 struct cifsSesInfo *ret_buf;
73
Steve French76849e32007-01-21 22:56:22 +000074 ret_buf = kzalloc(sizeof (struct cifsSesInfo), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 if (ret_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 write_lock(&GlobalSMBSeslock);
77 atomic_inc(&sesInfoAllocCount);
78 ret_buf->status = CifsNew;
79 list_add(&ret_buf->cifsSessionList, &GlobalSMBSessionList);
80 init_MUTEX(&ret_buf->sesSem);
81 write_unlock(&GlobalSMBSeslock);
82 }
83 return ret_buf;
84}
85
86void
87sesInfoFree(struct cifsSesInfo *buf_to_free)
88{
89 if (buf_to_free == NULL) {
90 cFYI(1, ("Null buffer passed to sesInfoFree"));
91 return;
92 }
93
94 write_lock(&GlobalSMBSeslock);
95 atomic_dec(&sesInfoAllocCount);
96 list_del(&buf_to_free->cifsSessionList);
97 write_unlock(&GlobalSMBSeslock);
Jesper Juhlf99d49a2005-11-07 01:01:34 -080098 kfree(buf_to_free->serverOS);
99 kfree(buf_to_free->serverDomain);
100 kfree(buf_to_free->serverNOS);
101 kfree(buf_to_free->password);
Steve French39798772006-05-31 22:40:51 +0000102 kfree(buf_to_free->domainName);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 kfree(buf_to_free);
104}
105
106struct cifsTconInfo *
107tconInfoAlloc(void)
108{
109 struct cifsTconInfo *ret_buf;
Steve French76849e32007-01-21 22:56:22 +0000110 ret_buf = kzalloc(sizeof (struct cifsTconInfo), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 if (ret_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 write_lock(&GlobalSMBSeslock);
113 atomic_inc(&tconInfoAllocCount);
114 list_add(&ret_buf->cifsConnectionList,
115 &GlobalTreeConnectionList);
116 ret_buf->tidStatus = CifsNew;
117 INIT_LIST_HEAD(&ret_buf->openFileList);
118 init_MUTEX(&ret_buf->tconSem);
119#ifdef CONFIG_CIFS_STATS
120 spin_lock_init(&ret_buf->stat_lock);
121#endif
122 write_unlock(&GlobalSMBSeslock);
123 }
124 return ret_buf;
125}
126
127void
128tconInfoFree(struct cifsTconInfo *buf_to_free)
129{
130 if (buf_to_free == NULL) {
131 cFYI(1, ("Null buffer passed to tconInfoFree"));
132 return;
133 }
134 write_lock(&GlobalSMBSeslock);
135 atomic_dec(&tconInfoAllocCount);
136 list_del(&buf_to_free->cifsConnectionList);
137 write_unlock(&GlobalSMBSeslock);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800138 kfree(buf_to_free->nativeFileSystem);
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
147/* 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
150 defaults to this and can not be bigger */
151 ret_buf =
Christoph Lametere94b1762006-12-06 20:33:17 -0800152 (struct smb_hdr *) mempool_alloc(cifs_req_poolp, GFP_KERNEL | GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /* clear the first few header bytes */
155 /* for most paths, more is cleared in header_assemble */
156 if (ret_buf) {
157 memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
158 atomic_inc(&bufAllocCount);
Steve French4498eed52005-12-03 13:58:57 -0800159#ifdef CONFIG_CIFS_STATS2
160 atomic_inc(&totBufAllocCount);
161#endif /* CONFIG_CIFS_STATS2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 }
163
164 return ret_buf;
165}
166
167void
168cifs_buf_release(void *buf_to_free)
169{
170
171 if (buf_to_free == NULL) {
172 /* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/
173 return;
174 }
175 mempool_free(buf_to_free,cifs_req_poolp);
176
177 atomic_dec(&bufAllocCount);
178 return;
179}
180
181struct smb_hdr *
182cifs_small_buf_get(void)
183{
184 struct smb_hdr *ret_buf = NULL;
185
186/* We could use negotiated size instead of max_msgsize -
187 but it may be more efficient to always alloc same size
188 albeit slightly larger than necessary and maxbuffersize
189 defaults to this and can not be bigger */
190 ret_buf =
Christoph Lametere94b1762006-12-06 20:33:17 -0800191 (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, GFP_KERNEL | GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (ret_buf) {
193 /* No need to clear memory here, cleared in header assemble */
194 /* memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
195 atomic_inc(&smBufAllocCount);
Steve French4498eed52005-12-03 13:58:57 -0800196#ifdef CONFIG_CIFS_STATS2
197 atomic_inc(&totSmBufAllocCount);
198#endif /* CONFIG_CIFS_STATS2 */
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 }
201 return ret_buf;
202}
203
204void
205cifs_small_buf_release(void *buf_to_free)
206{
207
208 if (buf_to_free == NULL) {
209 cFYI(1, ("Null buffer passed to cifs_small_buf_release"));
210 return;
211 }
212 mempool_free(buf_to_free,cifs_sm_req_poolp);
213
214 atomic_dec(&smBufAllocCount);
215 return;
216}
217
Steve French1982c342005-08-17 12:38:22 -0700218/*
219 Find a free multiplex id (SMB mid). Otherwise there could be
220 mid collisions which might cause problems, demultiplexing the
221 wrong response to this request. Multiplex ids could collide if
222 one of a series requests takes much longer than the others, or
223 if a very large number of long lived requests (byte range
224 locks or FindNotify requests) are pending. No more than
225 64K-1 requests can be outstanding at one time. If no
226 mids are available, return zero. A future optimization
227 could make the combination of mids and uid the key we use
228 to demultiplex on (rather than mid alone).
229 In addition to the above check, the cifs demultiplex
230 code already used the command code as a secondary
231 check of the frame and if signing is negotiated the
232 response would be discarded if the mid were the same
233 but the signature was wrong. Since the mid is not put in the
234 pending queue until later (when it is about to be dispatched)
235 we do have to limit the number of outstanding requests
236 to somewhat less than 64K-1 although it is hard to imagine
237 so many threads being in the vfs at one time.
238*/
239__u16 GetNextMid(struct TCP_Server_Info *server)
240{
241 __u16 mid = 0;
242 __u16 last_mid;
243 int collision;
244
245 if(server == NULL)
246 return mid;
247
248 spin_lock(&GlobalMid_Lock);
249 last_mid = server->CurrentMid; /* we do not want to loop forever */
250 server->CurrentMid++;
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 while(server->CurrentMid != last_mid) {
259 struct list_head *tmp;
260 struct mid_q_entry *mid_entry;
261
262 collision = 0;
263 if(server->CurrentMid == 0)
264 server->CurrentMid++;
265
266 list_for_each(tmp, &server->pending_mid_q) {
267 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
268
269 if ((mid_entry->mid == server->CurrentMid) &&
270 (mid_entry->midState == MID_REQUEST_SUBMITTED)) {
271 /* This mid is in use, try a different one */
272 collision = 1;
273 break;
274 }
275 }
276 if(collision == 0) {
277 mid = server->CurrentMid;
278 break;
279 }
280 server->CurrentMid++;
281 }
282 spin_unlock(&GlobalMid_Lock);
283 return mid;
284}
285
286/* NB: MID can not be set if treeCon not passed in, in that
287 case it is responsbility of caller to set the mid */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288void
289header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
290 const struct cifsTconInfo *treeCon, int word_count
291 /* length of fixed section (word count) in two byte units */)
292{
293 struct list_head* temp_item;
294 struct cifsSesInfo * ses;
295 char *temp = (char *) buffer;
296
Steve Frenchec637e32005-12-12 20:53:18 -0800297 memset(temp,0,256); /* bigger than MAX_CIFS_HDR_SIZE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 buffer->smb_buf_length =
300 (2 * word_count) + sizeof (struct smb_hdr) -
301 4 /* RFC 1001 length field does not count */ +
302 2 /* for bcc field itself */ ;
Steve French1982c342005-08-17 12:38:22 -0700303 /* Note that this is the only network field that has to be converted
304 to big endian and it is done just before we send it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 buffer->Protocol[0] = 0xFF;
307 buffer->Protocol[1] = 'S';
308 buffer->Protocol[2] = 'M';
309 buffer->Protocol[3] = 'B';
310 buffer->Command = smb_command;
311 buffer->Flags = 0x00; /* case sensitive */
312 buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
313 buffer->Pid = cpu_to_le16((__u16)current->tgid);
314 buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
315 spin_lock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 spin_unlock(&GlobalMid_Lock);
317 if (treeCon) {
318 buffer->Tid = treeCon->tid;
319 if (treeCon->ses) {
320 if (treeCon->ses->capabilities & CAP_UNICODE)
321 buffer->Flags2 |= SMBFLG2_UNICODE;
322 if (treeCon->ses->capabilities & CAP_STATUS32) {
323 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
324 }
Steve French1982c342005-08-17 12:38:22 -0700325 /* Uid is not converted */
326 buffer->Uid = treeCon->ses->Suid;
327 buffer->Mid = GetNextMid(treeCon->ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 if(multiuser_mount != 0) {
329 /* For the multiuser case, there are few obvious technically */
330 /* possible mechanisms to match the local linux user (uid) */
331 /* to a valid remote smb user (smb_uid): */
332 /* 1) Query Winbind (or other local pam/nss daemon */
333 /* for userid/password/logon_domain or credential */
334 /* 2) Query Winbind for uid to sid to username mapping */
335 /* and see if we have a matching password for existing*/
336 /* session for that user perhas getting password by */
337 /* adding a new pam_cifs module that stores passwords */
338 /* so that the cifs vfs can get at that for all logged*/
339 /* on users */
340 /* 3) (Which is the mechanism we have chosen) */
341 /* Search through sessions to the same server for a */
342 /* a match on the uid that was passed in on mount */
343 /* with the current processes uid (or euid?) and use */
344 /* that smb uid. If no existing smb session for */
345 /* that uid found, use the default smb session ie */
346 /* the smb session for the volume mounted which is */
347 /* the same as would be used if the multiuser mount */
348 /* flag were disabled. */
349
350 /* BB Add support for establishing new tCon and SMB Session */
351 /* with userid/password pairs found on the smb session */
352 /* for other target tcp/ip addresses BB */
Steve French83451872005-12-01 17:12:59 -0800353 if(current->fsuid != treeCon->ses->linux_uid) {
354 cFYI(1,("Multiuser mode and UID did not match tcon uid"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 read_lock(&GlobalSMBSeslock);
356 list_for_each(temp_item, &GlobalSMBSessionList) {
357 ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList);
Steve French83451872005-12-01 17:12:59 -0800358 if(ses->linux_uid == current->fsuid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if(ses->server == treeCon->ses->server) {
360 cFYI(1,("found matching uid substitute right smb_uid"));
361 buffer->Uid = ses->Suid;
362 break;
363 } else {
364 /* BB eventually call cifs_setup_session here */
365 cFYI(1,("local UID found but smb sess with this server does not exist"));
366 }
367 }
368 }
369 read_unlock(&GlobalSMBSeslock);
370 }
371 }
372 }
373 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
374 buffer->Flags2 |= SMBFLG2_DFS;
Steve Frenchd3485d32005-08-19 11:04:29 -0700375 if (treeCon->nocase)
376 buffer->Flags |= SMBFLG_CASELESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if((treeCon->ses) && (treeCon->ses->server))
378 if(treeCon->ses->server->secMode &
379 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
380 buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
381 }
382
383/* endian conversion of flags is now done just before sending */
384 buffer->WordCount = (char) word_count;
385 return;
386}
387
Steve French2cd646a2006-09-28 19:43:08 +0000388static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389checkSMBhdr(struct smb_hdr *smb, __u16 mid)
390{
391 /* Make sure that this really is an SMB, that it is a response,
392 and that the message ids match */
393 if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
394 (mid == smb->Mid)) {
395 if(smb->Flags & SMBFLG_RESPONSE)
396 return 0;
397 else {
398 /* only one valid case where server sends us request */
399 if(smb->Command == SMB_COM_LOCKING_ANDX)
400 return 0;
401 else
Steve French6ab16d22005-11-29 20:55:11 -0800402 cERROR(1, ("Rcvd Request not response"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 }
404 } else { /* bad signature or mid */
405 if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
406 cERROR(1,
Steve French6ab16d22005-11-29 20:55:11 -0800407 ("Bad protocol string signature header %x",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 *(unsigned int *) smb->Protocol));
409 if (mid != smb->Mid)
410 cERROR(1, ("Mids do not match"));
411 }
412 cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid));
413 return 1;
414}
415
416int
Steve Frenchd103e162006-10-12 17:49:24 +0000417checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418{
Steve French70ca7342005-09-22 16:32:06 -0700419 __u32 len = smb->smb_buf_length;
Steve French190fdeb2005-10-10 11:48:26 -0700420 __u32 clc_len; /* calculated length */
Steve French184ed212006-02-24 06:15:11 +0000421 cFYI(0, ("checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len));
Steve Frenchd103e162006-10-12 17:49:24 +0000422
423 if (length < 2 + sizeof (struct smb_hdr)) {
424 if ((length >= sizeof (struct smb_hdr) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 && (smb->Status.CifsError != 0)) {
Steve Frenchd103e162006-10-12 17:49:24 +0000426 smb->WordCount = 0;
427 /* some error cases do not return wct and bcc */
428 return 0;
429 } else if ((length == sizeof(struct smb_hdr) + 1) &&
430 (smb->WordCount == 0)) {
431 char * tmp = (char *)smb;
432 /* Need to work around a bug in two servers here */
433 /* First, check if the part of bcc they sent was zero */
434 if (tmp[sizeof(struct smb_hdr)] == 0) {
435 /* some servers return only half of bcc
436 * on simple responses (wct, bcc both zero)
437 * in particular have seen this on
438 * ulogoffX and FindClose. This leaves
439 * one byte of bcc potentially unitialized
440 */
441 /* zero rest of bcc */
442 tmp[sizeof(struct smb_hdr)+1] = 0;
Steve French46c79a62006-03-02 00:07:08 +0000443 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
Steve Frenchd103e162006-10-12 17:49:24 +0000445 cERROR(1,("rcvd invalid byte count (bcc)"));
446 } else {
447 cERROR(1, ("Length less than smb header size"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 }
Steve Frenchd103e162006-10-12 17:49:24 +0000449 return 1;
450 }
451 if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
452 cERROR(1, ("smb length greater than MaxBufSize, mid=%d",
Steve French184ed212006-02-24 06:15:11 +0000453 smb->Mid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return 1;
455 }
456
457 if (checkSMBhdr(smb, mid))
458 return 1;
Steve French190fdeb2005-10-10 11:48:26 -0700459 clc_len = smbCalcSize_LE(smb);
Steve French184ed212006-02-24 06:15:11 +0000460
Steve Frenchd103e162006-10-12 17:49:24 +0000461 if(4 + len != length) {
Steve French184ed212006-02-24 06:15:11 +0000462 cERROR(1, ("Length read does not match RFC1001 length %d",len));
463 return 1;
464 }
465
466 if (4 + len != clc_len) {
467 /* check if bcc wrapped around for large read responses */
468 if((len > 64 * 1024) && (len > clc_len)) {
469 /* check if lengths match mod 64K */
470 if(((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
471 return 0; /* bcc wrapped */
472 }
Steve French46c79a62006-03-02 00:07:08 +0000473 cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
474 clc_len, 4 + len, smb->Mid));
Steve French190fdeb2005-10-10 11:48:26 -0700475 /* Windows XP can return a few bytes too much, presumably
476 an illegal pad, at the end of byte range lock responses
Steve French6ab16d22005-11-29 20:55:11 -0800477 so we allow for that three byte pad, as long as actual
Steve French190fdeb2005-10-10 11:48:26 -0700478 received length is as long or longer than calculated length */
Steve French6ab16d22005-11-29 20:55:11 -0800479 /* We have now had to extend this more, since there is a
480 case in which it needs to be bigger still to handle a
481 malformed response to transact2 findfirst from WinXP when
482 access denied is returned and thus bcc and wct are zero
483 but server says length is 0x21 bytes too long as if the server
484 forget to reset the smb rfc1001 length when it reset the
485 wct and bcc to minimum size and drop the t2 parms and data */
486 if((4+len > clc_len) && (len <= clc_len + 512))
Steve French190fdeb2005-10-10 11:48:26 -0700487 return 0;
Steve French46c79a62006-03-02 00:07:08 +0000488 else {
489 cERROR(1, ("RFC1001 size %d bigger than SMB for Mid=%d",
490 len, smb->Mid));
Steve French190fdeb2005-10-10 11:48:26 -0700491 return 1;
Steve French46c79a62006-03-02 00:07:08 +0000492 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 }
Steve French20962432005-09-21 22:05:57 -0700494 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495}
496int
Steve Frenchd7c8c942006-03-03 10:43:49 +0000497is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
499 struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)buf;
500 struct list_head *tmp;
501 struct list_head *tmp1;
502 struct cifsTconInfo *tcon;
503 struct cifsFileInfo *netfile;
504
505 cFYI(1,("Checking for oplock break or dnotify response"));
506 if((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
507 (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
508 struct smb_com_transaction_change_notify_rsp * pSMBr =
509 (struct smb_com_transaction_change_notify_rsp *)buf;
510 struct file_notify_information * pnotify;
511 __u32 data_offset = 0;
512 if(pSMBr->ByteCount > sizeof(struct file_notify_information)) {
513 data_offset = le32_to_cpu(pSMBr->DataOffset);
514
Steve French39798772006-05-31 22:40:51 +0000515 pnotify = (struct file_notify_information *)
516 ((char *)&pSMBr->hdr.Protocol + data_offset);
517 cFYI(1,("dnotify on %s Action: 0x%x",pnotify->FileName,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 pnotify->Action)); /* BB removeme BB */
Steve French39798772006-05-31 22:40:51 +0000519 /* cifs_dump_mem("Rcvd notify Data: ",buf,
520 sizeof(struct smb_hdr)+60); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 return TRUE;
522 }
523 if(pSMBr->hdr.Status.CifsError) {
524 cFYI(1,("notify err 0x%d",pSMBr->hdr.Status.CifsError));
525 return TRUE;
526 }
527 return FALSE;
528 }
529 if(pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
530 return FALSE;
531 if(pSMB->hdr.Flags & SMBFLG_RESPONSE) {
532 /* no sense logging error on invalid handle on oplock
533 break - harmless race between close request and oplock
534 break response is expected from time to time writing out
535 large dirty files cached on the client */
536 if ((NT_STATUS_INVALID_HANDLE) ==
537 le32_to_cpu(pSMB->hdr.Status.CifsError)) {
538 cFYI(1,("invalid handle on oplock break"));
539 return TRUE;
540 } else if (ERRbadfid ==
541 le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
542 return TRUE;
543 } else {
544 return FALSE; /* on valid oplock brk we get "request" */
545 }
546 }
547 if(pSMB->hdr.WordCount != 8)
548 return FALSE;
549
550 cFYI(1,(" oplock type 0x%d level 0x%d",pSMB->LockType,pSMB->OplockLevel));
551 if(!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
552 return FALSE;
553
554 /* look up tcon based on tid & uid */
555 read_lock(&GlobalSMBSeslock);
556 list_for_each(tmp, &GlobalTreeConnectionList) {
557 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
Steve Frenchd7c8c942006-03-03 10:43:49 +0000558 if ((tcon->tid == buf->Tid) && (srv == tcon->ses->server)) {
Steve Frencha4544342005-08-24 13:59:35 -0700559 cifs_stats_inc(&tcon->num_oplock_brks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 list_for_each(tmp1,&tcon->openFileList){
Steve French57337e42005-04-28 22:41:10 -0700561 netfile = list_entry(tmp1,struct cifsFileInfo,
562 tlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if(pSMB->Fid == netfile->netfid) {
564 struct cifsInodeInfo *pCifsInode;
565 read_unlock(&GlobalSMBSeslock);
Steve French57337e42005-04-28 22:41:10 -0700566 cFYI(1,("file id match, oplock break"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 pCifsInode =
568 CIFS_I(netfile->pInode);
569 pCifsInode->clientCanCacheAll = FALSE;
570 if(pSMB->OplockLevel == 0)
Steve French57337e42005-04-28 22:41:10 -0700571 pCifsInode->clientCanCacheRead
572 = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 pCifsInode->oplockPending = TRUE;
Steve French57337e42005-04-28 22:41:10 -0700574 AllocOplockQEntry(netfile->pInode,
575 netfile->netfid,
576 tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 cFYI(1,("about to wake up oplock thd"));
Steve French57337e42005-04-28 22:41:10 -0700578 if(oplockThread)
579 wake_up_process(oplockThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 return TRUE;
581 }
582 }
583 read_unlock(&GlobalSMBSeslock);
Steve French57337e42005-04-28 22:41:10 -0700584 cFYI(1,("No matching file for oplock break"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 return TRUE;
586 }
587 }
588 read_unlock(&GlobalSMBSeslock);
589 cFYI(1,("Can not process oplock break for non-existent connection"));
590 return TRUE;
591}
592
593void
594dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
595{
596 int i, j;
597 char debug_line[17];
598 unsigned char *buffer;
599
600 if (traceSMB == 0)
601 return;
602
603 buffer = (unsigned char *) smb_buf;
604 for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
Steve French57337e42005-04-28 22:41:10 -0700605 if (i % 8 == 0) { /* have reached the beginning of line */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 printk(KERN_DEBUG "| ");
607 j = 0;
608 }
609 printk("%0#4x ", buffer[i]);
610 debug_line[2 * j] = ' ';
611 if (isprint(buffer[i]))
612 debug_line[1 + (2 * j)] = buffer[i];
613 else
614 debug_line[1 + (2 * j)] = '_';
615
Steve French57337e42005-04-28 22:41:10 -0700616 if (i % 8 == 7) { /* reached end of line, time to print ascii */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 debug_line[16] = 0;
618 printk(" | %s\n", debug_line);
619 }
620 }
621 for (; j < 8; j++) {
622 printk(" ");
623 debug_line[2 * j] = ' ';
624 debug_line[1 + (2 * j)] = ' ';
625 }
626 printk( " | %s\n", debug_line);
627 return;
628}
Steve French6a0b4822005-04-28 22:41:05 -0700629
Steve French6a0b4822005-04-28 22:41:05 -0700630/* Windows maps these to the user defined 16 bit Unicode range since they are
631 reserved symbols (along with \ and /), otherwise illegal to store
632 in filenames in NTFS */
Steve Frenchd0724712005-04-28 22:41:06 -0700633#define UNI_ASTERIK (__u16) ('*' + 0xF000)
634#define UNI_QUESTION (__u16) ('?' + 0xF000)
635#define UNI_COLON (__u16) (':' + 0xF000)
636#define UNI_GRTRTHAN (__u16) ('>' + 0xF000)
637#define UNI_LESSTHAN (__u16) ('<' + 0xF000)
638#define UNI_PIPE (__u16) ('|' + 0xF000)
639#define UNI_SLASH (__u16) ('\\' + 0xF000)
Steve French6a0b4822005-04-28 22:41:05 -0700640
641/* Convert 16 bit Unicode pathname from wire format to string in current code
642 page. Conversion may involve remapping up the seven characters that are
643 only legal in POSIX-like OS (if they are present in the string). Path
644 names are little endian 16 bit Unicode on the wire */
645int
646cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
647 const struct nls_table * cp)
648{
649 int i,j,len;
Steve Frenchd0724712005-04-28 22:41:06 -0700650 __u16 src_char;
Steve French6a0b4822005-04-28 22:41:05 -0700651
652 for(i = 0, j = 0; i < maxlen; i++) {
653 src_char = le16_to_cpu(source[i]);
654 switch (src_char) {
655 case 0:
656 goto cUCS_out; /* BB check this BB */
657 case UNI_COLON:
658 target[j] = ':';
659 break;
660 case UNI_ASTERIK:
661 target[j] = '*';
662 break;
663 case UNI_QUESTION:
664 target[j] = '?';
665 break;
Steve French6c91d362005-04-28 22:41:06 -0700666 /* BB We can not handle remapping slash until
667 all the calls to build_path_from_dentry
668 are modified, as they use slash as separator BB */
669 /* case UNI_SLASH:
670 target[j] = '\\';
671 break;*/
Steve French6a0b4822005-04-28 22:41:05 -0700672 case UNI_PIPE:
673 target[j] = '|';
674 break;
675 case UNI_GRTRTHAN:
676 target[j] = '>';
677 break;
678 case UNI_LESSTHAN:
679 target[j] = '<';
Steve French67594fe2005-05-17 13:04:49 -0500680 break;
Steve French6a0b4822005-04-28 22:41:05 -0700681 default:
682 len = cp->uni2char(src_char, &target[j],
683 NLS_MAX_CHARSET_SIZE);
684 if(len > 0) {
685 j += len;
686 continue;
687 } else {
688 target[j] = '?';
689 }
690 }
691 j++;
Steve French57337e42005-04-28 22:41:10 -0700692 /* make sure we do not overrun callers allocated temp buffer */
Steve French6a0b4822005-04-28 22:41:05 -0700693 if(j >= (2 * NAME_MAX))
694 break;
695 }
696cUCS_out:
697 target[j] = 0;
698 return j;
699}
Steve French6c91d362005-04-28 22:41:06 -0700700
701/* Convert 16 bit Unicode pathname to wire format from string in current code
702 page. Conversion may involve remapping up the seven characters that are
703 only legal in POSIX-like OS (if they are present in the string). Path
704 names are little endian 16 bit Unicode on the wire */
705int
706cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
707 const struct nls_table * cp, int mapChars)
708{
709 int i,j,charlen;
710 int len_remaining = maxlen;
711 char src_char;
Steve French70ca7342005-09-22 16:32:06 -0700712 __u16 temp;
Steve French6c91d362005-04-28 22:41:06 -0700713
714 if(!mapChars)
Steve Frenche89dc922005-11-11 15:18:19 -0800715 return cifs_strtoUCS(target, source, PATH_MAX, cp);
Steve French6c91d362005-04-28 22:41:06 -0700716
717 for(i = 0, j = 0; i < maxlen; j++) {
718 src_char = source[i];
719 switch (src_char) {
720 case 0:
Steve Frenchf4cfd692005-07-14 18:29:02 -0500721 target[j] = 0;
Steve French6c91d362005-04-28 22:41:06 -0700722 goto ctoUCS_out;
723 case ':':
724 target[j] = cpu_to_le16(UNI_COLON);
725 break;
726 case '*':
727 target[j] = cpu_to_le16(UNI_ASTERIK);
728 break;
729 case '?':
730 target[j] = cpu_to_le16(UNI_QUESTION);
731 break;
732 case '<':
733 target[j] = cpu_to_le16(UNI_LESSTHAN);
734 break;
735 case '>':
736 target[j] = cpu_to_le16(UNI_GRTRTHAN);
737 break;
738 case '|':
739 target[j] = cpu_to_le16(UNI_PIPE);
740 break;
741 /* BB We can not handle remapping slash until
742 all the calls to build_path_from_dentry
743 are modified, as they use slash as separator BB */
744 /* case '\\':
745 target[j] = cpu_to_le16(UNI_SLASH);
746 break;*/
747 default:
748 charlen = cp->char2uni(source+i,
Steve French70ca7342005-09-22 16:32:06 -0700749 len_remaining, &temp);
Steve French6c91d362005-04-28 22:41:06 -0700750 /* if no match, use question mark, which
751 at least in some cases servers as wild card */
752 if(charlen < 1) {
753 target[j] = cpu_to_le16(0x003f);
754 charlen = 1;
Steve French70ca7342005-09-22 16:32:06 -0700755 } else
756 target[j] = cpu_to_le16(temp);
Steve French6c91d362005-04-28 22:41:06 -0700757 len_remaining -= charlen;
758 /* character may take more than one byte in the
759 the source string, but will take exactly two
760 bytes in the target string */
761 i+= charlen;
762 continue;
763 }
764 i++; /* move to next char in source string */
765 len_remaining--;
766 }
767
768ctoUCS_out:
769 return i;
770}