blob: 94baf6c8ecbda85946984cd2e4d524034cc94644 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/misc.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2004
5 * 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
74 ret_buf =
75 (struct cifsSesInfo *) kmalloc(sizeof (struct cifsSesInfo),
76 GFP_KERNEL);
77 if (ret_buf) {
78 memset(ret_buf, 0, sizeof (struct cifsSesInfo));
79 write_lock(&GlobalSMBSeslock);
80 atomic_inc(&sesInfoAllocCount);
81 ret_buf->status = CifsNew;
82 list_add(&ret_buf->cifsSessionList, &GlobalSMBSessionList);
83 init_MUTEX(&ret_buf->sesSem);
84 write_unlock(&GlobalSMBSeslock);
85 }
86 return ret_buf;
87}
88
89void
90sesInfoFree(struct cifsSesInfo *buf_to_free)
91{
92 if (buf_to_free == NULL) {
93 cFYI(1, ("Null buffer passed to sesInfoFree"));
94 return;
95 }
96
97 write_lock(&GlobalSMBSeslock);
98 atomic_dec(&sesInfoAllocCount);
99 list_del(&buf_to_free->cifsSessionList);
100 write_unlock(&GlobalSMBSeslock);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800101 kfree(buf_to_free->serverOS);
102 kfree(buf_to_free->serverDomain);
103 kfree(buf_to_free->serverNOS);
104 kfree(buf_to_free->password);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 kfree(buf_to_free);
106}
107
108struct cifsTconInfo *
109tconInfoAlloc(void)
110{
111 struct cifsTconInfo *ret_buf;
112 ret_buf =
113 (struct cifsTconInfo *) kmalloc(sizeof (struct cifsTconInfo),
114 GFP_KERNEL);
115 if (ret_buf) {
116 memset(ret_buf, 0, sizeof (struct cifsTconInfo));
117 write_lock(&GlobalSMBSeslock);
118 atomic_inc(&tconInfoAllocCount);
119 list_add(&ret_buf->cifsConnectionList,
120 &GlobalTreeConnectionList);
121 ret_buf->tidStatus = CifsNew;
122 INIT_LIST_HEAD(&ret_buf->openFileList);
123 init_MUTEX(&ret_buf->tconSem);
124#ifdef CONFIG_CIFS_STATS
125 spin_lock_init(&ret_buf->stat_lock);
126#endif
127 write_unlock(&GlobalSMBSeslock);
128 }
129 return ret_buf;
130}
131
132void
133tconInfoFree(struct cifsTconInfo *buf_to_free)
134{
135 if (buf_to_free == NULL) {
136 cFYI(1, ("Null buffer passed to tconInfoFree"));
137 return;
138 }
139 write_lock(&GlobalSMBSeslock);
140 atomic_dec(&tconInfoAllocCount);
141 list_del(&buf_to_free->cifsConnectionList);
142 write_unlock(&GlobalSMBSeslock);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800143 kfree(buf_to_free->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 kfree(buf_to_free);
145}
146
147struct smb_hdr *
148cifs_buf_get(void)
149{
150 struct smb_hdr *ret_buf = NULL;
151
152/* We could use negotiated size instead of max_msgsize -
153 but it may be more efficient to always alloc same size
154 albeit slightly larger than necessary and maxbuffersize
155 defaults to this and can not be bigger */
156 ret_buf =
157 (struct smb_hdr *) mempool_alloc(cifs_req_poolp, SLAB_KERNEL | SLAB_NOFS);
158
159 /* clear the first few header bytes */
160 /* for most paths, more is cleared in header_assemble */
161 if (ret_buf) {
162 memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
163 atomic_inc(&bufAllocCount);
164 }
165
166 return ret_buf;
167}
168
169void
170cifs_buf_release(void *buf_to_free)
171{
172
173 if (buf_to_free == NULL) {
174 /* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/
175 return;
176 }
177 mempool_free(buf_to_free,cifs_req_poolp);
178
179 atomic_dec(&bufAllocCount);
180 return;
181}
182
183struct smb_hdr *
184cifs_small_buf_get(void)
185{
186 struct smb_hdr *ret_buf = NULL;
187
188/* We could use negotiated size instead of max_msgsize -
189 but it may be more efficient to always alloc same size
190 albeit slightly larger than necessary and maxbuffersize
191 defaults to this and can not be bigger */
192 ret_buf =
193 (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, SLAB_KERNEL | SLAB_NOFS);
194 if (ret_buf) {
195 /* No need to clear memory here, cleared in header assemble */
196 /* memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
197 atomic_inc(&smBufAllocCount);
198 }
199 return ret_buf;
200}
201
202void
203cifs_small_buf_release(void *buf_to_free)
204{
205
206 if (buf_to_free == NULL) {
207 cFYI(1, ("Null buffer passed to cifs_small_buf_release"));
208 return;
209 }
210 mempool_free(buf_to_free,cifs_sm_req_poolp);
211
212 atomic_dec(&smBufAllocCount);
213 return;
214}
215
Steve French1982c342005-08-17 12:38:22 -0700216/*
217 Find a free multiplex id (SMB mid). Otherwise there could be
218 mid collisions which might cause problems, demultiplexing the
219 wrong response to this request. Multiplex ids could collide if
220 one of a series requests takes much longer than the others, or
221 if a very large number of long lived requests (byte range
222 locks or FindNotify requests) are pending. No more than
223 64K-1 requests can be outstanding at one time. If no
224 mids are available, return zero. A future optimization
225 could make the combination of mids and uid the key we use
226 to demultiplex on (rather than mid alone).
227 In addition to the above check, the cifs demultiplex
228 code already used the command code as a secondary
229 check of the frame and if signing is negotiated the
230 response would be discarded if the mid were the same
231 but the signature was wrong. Since the mid is not put in the
232 pending queue until later (when it is about to be dispatched)
233 we do have to limit the number of outstanding requests
234 to somewhat less than 64K-1 although it is hard to imagine
235 so many threads being in the vfs at one time.
236*/
237__u16 GetNextMid(struct TCP_Server_Info *server)
238{
239 __u16 mid = 0;
240 __u16 last_mid;
241 int collision;
242
243 if(server == NULL)
244 return mid;
245
246 spin_lock(&GlobalMid_Lock);
247 last_mid = server->CurrentMid; /* we do not want to loop forever */
248 server->CurrentMid++;
249 /* This nested loop looks more expensive than it is.
250 In practice the list of pending requests is short,
251 fewer than 50, and the mids are likely to be unique
252 on the first pass through the loop unless some request
253 takes longer than the 64 thousand requests before it
254 (and it would also have to have been a request that
255 did not time out) */
256 while(server->CurrentMid != last_mid) {
257 struct list_head *tmp;
258 struct mid_q_entry *mid_entry;
259
260 collision = 0;
261 if(server->CurrentMid == 0)
262 server->CurrentMid++;
263
264 list_for_each(tmp, &server->pending_mid_q) {
265 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
266
267 if ((mid_entry->mid == server->CurrentMid) &&
268 (mid_entry->midState == MID_REQUEST_SUBMITTED)) {
269 /* This mid is in use, try a different one */
270 collision = 1;
271 break;
272 }
273 }
274 if(collision == 0) {
275 mid = server->CurrentMid;
276 break;
277 }
278 server->CurrentMid++;
279 }
280 spin_unlock(&GlobalMid_Lock);
281 return mid;
282}
283
284/* NB: MID can not be set if treeCon not passed in, in that
285 case it is responsbility of caller to set the mid */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286void
287header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
288 const struct cifsTconInfo *treeCon, int word_count
289 /* length of fixed section (word count) in two byte units */)
290{
291 struct list_head* temp_item;
292 struct cifsSesInfo * ses;
293 char *temp = (char *) buffer;
294
295 memset(temp,0,MAX_CIFS_HDR_SIZE);
296
297 buffer->smb_buf_length =
298 (2 * word_count) + sizeof (struct smb_hdr) -
299 4 /* RFC 1001 length field does not count */ +
300 2 /* for bcc field itself */ ;
Steve French1982c342005-08-17 12:38:22 -0700301 /* Note that this is the only network field that has to be converted
302 to big endian and it is done just before we send it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 buffer->Protocol[0] = 0xFF;
305 buffer->Protocol[1] = 'S';
306 buffer->Protocol[2] = 'M';
307 buffer->Protocol[3] = 'B';
308 buffer->Command = smb_command;
309 buffer->Flags = 0x00; /* case sensitive */
310 buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
311 buffer->Pid = cpu_to_le16((__u16)current->tgid);
312 buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
313 spin_lock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 spin_unlock(&GlobalMid_Lock);
315 if (treeCon) {
316 buffer->Tid = treeCon->tid;
317 if (treeCon->ses) {
318 if (treeCon->ses->capabilities & CAP_UNICODE)
319 buffer->Flags2 |= SMBFLG2_UNICODE;
320 if (treeCon->ses->capabilities & CAP_STATUS32) {
321 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
322 }
Steve French1982c342005-08-17 12:38:22 -0700323 /* Uid is not converted */
324 buffer->Uid = treeCon->ses->Suid;
325 buffer->Mid = GetNextMid(treeCon->ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 if(multiuser_mount != 0) {
327 /* For the multiuser case, there are few obvious technically */
328 /* possible mechanisms to match the local linux user (uid) */
329 /* to a valid remote smb user (smb_uid): */
330 /* 1) Query Winbind (or other local pam/nss daemon */
331 /* for userid/password/logon_domain or credential */
332 /* 2) Query Winbind for uid to sid to username mapping */
333 /* and see if we have a matching password for existing*/
334 /* session for that user perhas getting password by */
335 /* adding a new pam_cifs module that stores passwords */
336 /* so that the cifs vfs can get at that for all logged*/
337 /* on users */
338 /* 3) (Which is the mechanism we have chosen) */
339 /* Search through sessions to the same server for a */
340 /* a match on the uid that was passed in on mount */
341 /* with the current processes uid (or euid?) and use */
342 /* that smb uid. If no existing smb session for */
343 /* that uid found, use the default smb session ie */
344 /* the smb session for the volume mounted which is */
345 /* the same as would be used if the multiuser mount */
346 /* flag were disabled. */
347
348 /* BB Add support for establishing new tCon and SMB Session */
349 /* with userid/password pairs found on the smb session */
350 /* for other target tcp/ip addresses BB */
351 if(current->uid != treeCon->ses->linux_uid) {
352 cFYI(1,("Multiuser mode and UID did not match tcon uid "));
353 read_lock(&GlobalSMBSeslock);
354 list_for_each(temp_item, &GlobalSMBSessionList) {
355 ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList);
356 if(ses->linux_uid == current->uid) {
357 if(ses->server == treeCon->ses->server) {
358 cFYI(1,("found matching uid substitute right smb_uid"));
359 buffer->Uid = ses->Suid;
360 break;
361 } else {
362 /* BB eventually call cifs_setup_session here */
363 cFYI(1,("local UID found but smb sess with this server does not exist"));
364 }
365 }
366 }
367 read_unlock(&GlobalSMBSeslock);
368 }
369 }
370 }
371 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
372 buffer->Flags2 |= SMBFLG2_DFS;
Steve Frenchd3485d32005-08-19 11:04:29 -0700373 if (treeCon->nocase)
374 buffer->Flags |= SMBFLG_CASELESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 if((treeCon->ses) && (treeCon->ses->server))
376 if(treeCon->ses->server->secMode &
377 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
378 buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
379 }
380
381/* endian conversion of flags is now done just before sending */
382 buffer->WordCount = (char) word_count;
383 return;
384}
385
386int
387checkSMBhdr(struct smb_hdr *smb, __u16 mid)
388{
389 /* Make sure that this really is an SMB, that it is a response,
390 and that the message ids match */
391 if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
392 (mid == smb->Mid)) {
393 if(smb->Flags & SMBFLG_RESPONSE)
394 return 0;
395 else {
396 /* only one valid case where server sends us request */
397 if(smb->Command == SMB_COM_LOCKING_ANDX)
398 return 0;
399 else
Steve French6ab16d22005-11-29 20:55:11 -0800400 cERROR(1, ("Rcvd Request not response"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 }
402 } else { /* bad signature or mid */
403 if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
404 cERROR(1,
Steve French6ab16d22005-11-29 20:55:11 -0800405 ("Bad protocol string signature header %x",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 *(unsigned int *) smb->Protocol));
407 if (mid != smb->Mid)
408 cERROR(1, ("Mids do not match"));
409 }
410 cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid));
411 return 1;
412}
413
414int
415checkSMB(struct smb_hdr *smb, __u16 mid, int length)
416{
Steve French70ca7342005-09-22 16:32:06 -0700417 __u32 len = smb->smb_buf_length;
Steve French190fdeb2005-10-10 11:48:26 -0700418 __u32 clc_len; /* calculated length */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 cFYI(0,
Steve French6ab16d22005-11-29 20:55:11 -0800420 ("Entering checkSMB with Length: %x, smb_buf_length: %x",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 length, len));
422 if (((unsigned int)length < 2 + sizeof (struct smb_hdr)) ||
423 (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4)) {
424 if ((unsigned int)length < 2 + sizeof (struct smb_hdr)) {
425 if (((unsigned int)length >=
426 sizeof (struct smb_hdr) - 1)
427 && (smb->Status.CifsError != 0)) {
428 smb->WordCount = 0;
429 return 0; /* some error cases do not return wct and bcc */
430 } else {
431 cERROR(1, ("Length less than smb header size"));
432 }
433
434 }
435 if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4)
436 cERROR(1,
437 ("smb_buf_length greater than MaxBufSize"));
438 cERROR(1,
Steve French190fdeb2005-10-10 11:48:26 -0700439 ("bad smb detected. Illegal length. mid=%d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 smb->Mid));
441 return 1;
442 }
443
444 if (checkSMBhdr(smb, mid))
445 return 1;
Steve French190fdeb2005-10-10 11:48:26 -0700446 clc_len = smbCalcSize_LE(smb);
447 if ((4 + len != clc_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 || (4 + len != (unsigned int)length)) {
Steve French190fdeb2005-10-10 11:48:26 -0700449 cERROR(1, ("Calculated size 0x%x vs actual length 0x%x",
450 clc_len, 4 + len));
451 cERROR(1, ("bad smb size detected for Mid=%d", smb->Mid));
452 /* Windows XP can return a few bytes too much, presumably
453 an illegal pad, at the end of byte range lock responses
Steve French6ab16d22005-11-29 20:55:11 -0800454 so we allow for that three byte pad, as long as actual
Steve French190fdeb2005-10-10 11:48:26 -0700455 received length is as long or longer than calculated length */
Steve French6ab16d22005-11-29 20:55:11 -0800456 /* We have now had to extend this more, since there is a
457 case in which it needs to be bigger still to handle a
458 malformed response to transact2 findfirst from WinXP when
459 access denied is returned and thus bcc and wct are zero
460 but server says length is 0x21 bytes too long as if the server
461 forget to reset the smb rfc1001 length when it reset the
462 wct and bcc to minimum size and drop the t2 parms and data */
463 if((4+len > clc_len) && (len <= clc_len + 512))
Steve French190fdeb2005-10-10 11:48:26 -0700464 return 0;
465 else
466 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 }
Steve French20962432005-09-21 22:05:57 -0700468 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470int
471is_valid_oplock_break(struct smb_hdr *buf)
472{
473 struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)buf;
474 struct list_head *tmp;
475 struct list_head *tmp1;
476 struct cifsTconInfo *tcon;
477 struct cifsFileInfo *netfile;
478
479 cFYI(1,("Checking for oplock break or dnotify response"));
480 if((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
481 (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
482 struct smb_com_transaction_change_notify_rsp * pSMBr =
483 (struct smb_com_transaction_change_notify_rsp *)buf;
484 struct file_notify_information * pnotify;
485 __u32 data_offset = 0;
486 if(pSMBr->ByteCount > sizeof(struct file_notify_information)) {
487 data_offset = le32_to_cpu(pSMBr->DataOffset);
488
489 pnotify = (struct file_notify_information *)((char *)&pSMBr->hdr.Protocol
490 + data_offset);
491 cFYI(1,("dnotify on %s with action: 0x%x",pnotify->FileName,
492 pnotify->Action)); /* BB removeme BB */
493 /* cifs_dump_mem("Received notify Data is: ",buf,sizeof(struct smb_hdr)+60); */
494 return TRUE;
495 }
496 if(pSMBr->hdr.Status.CifsError) {
497 cFYI(1,("notify err 0x%d",pSMBr->hdr.Status.CifsError));
498 return TRUE;
499 }
500 return FALSE;
501 }
502 if(pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
503 return FALSE;
504 if(pSMB->hdr.Flags & SMBFLG_RESPONSE) {
505 /* no sense logging error on invalid handle on oplock
506 break - harmless race between close request and oplock
507 break response is expected from time to time writing out
508 large dirty files cached on the client */
509 if ((NT_STATUS_INVALID_HANDLE) ==
510 le32_to_cpu(pSMB->hdr.Status.CifsError)) {
511 cFYI(1,("invalid handle on oplock break"));
512 return TRUE;
513 } else if (ERRbadfid ==
514 le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
515 return TRUE;
516 } else {
517 return FALSE; /* on valid oplock brk we get "request" */
518 }
519 }
520 if(pSMB->hdr.WordCount != 8)
521 return FALSE;
522
523 cFYI(1,(" oplock type 0x%d level 0x%d",pSMB->LockType,pSMB->OplockLevel));
524 if(!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
525 return FALSE;
526
527 /* look up tcon based on tid & uid */
528 read_lock(&GlobalSMBSeslock);
529 list_for_each(tmp, &GlobalTreeConnectionList) {
530 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
531 if (tcon->tid == buf->Tid) {
Steve Frencha45443472005-08-24 13:59:35 -0700532 cifs_stats_inc(&tcon->num_oplock_brks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 list_for_each(tmp1,&tcon->openFileList){
Steve French57337e42005-04-28 22:41:10 -0700534 netfile = list_entry(tmp1,struct cifsFileInfo,
535 tlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if(pSMB->Fid == netfile->netfid) {
537 struct cifsInodeInfo *pCifsInode;
538 read_unlock(&GlobalSMBSeslock);
Steve French57337e42005-04-28 22:41:10 -0700539 cFYI(1,("file id match, oplock break"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 pCifsInode =
541 CIFS_I(netfile->pInode);
542 pCifsInode->clientCanCacheAll = FALSE;
543 if(pSMB->OplockLevel == 0)
Steve French57337e42005-04-28 22:41:10 -0700544 pCifsInode->clientCanCacheRead
545 = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 pCifsInode->oplockPending = TRUE;
Steve French57337e42005-04-28 22:41:10 -0700547 AllocOplockQEntry(netfile->pInode,
548 netfile->netfid,
549 tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 cFYI(1,("about to wake up oplock thd"));
Steve French57337e42005-04-28 22:41:10 -0700551 if(oplockThread)
552 wake_up_process(oplockThread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 return TRUE;
554 }
555 }
556 read_unlock(&GlobalSMBSeslock);
Steve French57337e42005-04-28 22:41:10 -0700557 cFYI(1,("No matching file for oplock break"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return TRUE;
559 }
560 }
561 read_unlock(&GlobalSMBSeslock);
562 cFYI(1,("Can not process oplock break for non-existent connection"));
563 return TRUE;
564}
565
566void
567dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
568{
569 int i, j;
570 char debug_line[17];
571 unsigned char *buffer;
572
573 if (traceSMB == 0)
574 return;
575
576 buffer = (unsigned char *) smb_buf;
577 for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
Steve French57337e42005-04-28 22:41:10 -0700578 if (i % 8 == 0) { /* have reached the beginning of line */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 printk(KERN_DEBUG "| ");
580 j = 0;
581 }
582 printk("%0#4x ", buffer[i]);
583 debug_line[2 * j] = ' ';
584 if (isprint(buffer[i]))
585 debug_line[1 + (2 * j)] = buffer[i];
586 else
587 debug_line[1 + (2 * j)] = '_';
588
Steve French57337e42005-04-28 22:41:10 -0700589 if (i % 8 == 7) { /* reached end of line, time to print ascii */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 debug_line[16] = 0;
591 printk(" | %s\n", debug_line);
592 }
593 }
594 for (; j < 8; j++) {
595 printk(" ");
596 debug_line[2 * j] = ' ';
597 debug_line[1 + (2 * j)] = ' ';
598 }
599 printk( " | %s\n", debug_line);
600 return;
601}
Steve French6a0b4822005-04-28 22:41:05 -0700602
Steve French6a0b4822005-04-28 22:41:05 -0700603/* Windows maps these to the user defined 16 bit Unicode range since they are
604 reserved symbols (along with \ and /), otherwise illegal to store
605 in filenames in NTFS */
Steve Frenchd0724712005-04-28 22:41:06 -0700606#define UNI_ASTERIK (__u16) ('*' + 0xF000)
607#define UNI_QUESTION (__u16) ('?' + 0xF000)
608#define UNI_COLON (__u16) (':' + 0xF000)
609#define UNI_GRTRTHAN (__u16) ('>' + 0xF000)
610#define UNI_LESSTHAN (__u16) ('<' + 0xF000)
611#define UNI_PIPE (__u16) ('|' + 0xF000)
612#define UNI_SLASH (__u16) ('\\' + 0xF000)
Steve French6a0b4822005-04-28 22:41:05 -0700613
614/* Convert 16 bit Unicode pathname from wire format to string in current code
615 page. Conversion may involve remapping up the seven characters that are
616 only legal in POSIX-like OS (if they are present in the string). Path
617 names are little endian 16 bit Unicode on the wire */
618int
619cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
620 const struct nls_table * cp)
621{
622 int i,j,len;
Steve Frenchd0724712005-04-28 22:41:06 -0700623 __u16 src_char;
Steve French6a0b4822005-04-28 22:41:05 -0700624
625 for(i = 0, j = 0; i < maxlen; i++) {
626 src_char = le16_to_cpu(source[i]);
627 switch (src_char) {
628 case 0:
629 goto cUCS_out; /* BB check this BB */
630 case UNI_COLON:
631 target[j] = ':';
632 break;
633 case UNI_ASTERIK:
634 target[j] = '*';
635 break;
636 case UNI_QUESTION:
637 target[j] = '?';
638 break;
Steve French6c91d362005-04-28 22:41:06 -0700639 /* BB We can not handle remapping slash until
640 all the calls to build_path_from_dentry
641 are modified, as they use slash as separator BB */
642 /* case UNI_SLASH:
643 target[j] = '\\';
644 break;*/
Steve French6a0b4822005-04-28 22:41:05 -0700645 case UNI_PIPE:
646 target[j] = '|';
647 break;
648 case UNI_GRTRTHAN:
649 target[j] = '>';
650 break;
651 case UNI_LESSTHAN:
652 target[j] = '<';
Steve French67594fe2005-05-17 13:04:49 -0500653 break;
Steve French6a0b4822005-04-28 22:41:05 -0700654 default:
655 len = cp->uni2char(src_char, &target[j],
656 NLS_MAX_CHARSET_SIZE);
657 if(len > 0) {
658 j += len;
659 continue;
660 } else {
661 target[j] = '?';
662 }
663 }
664 j++;
Steve French57337e42005-04-28 22:41:10 -0700665 /* make sure we do not overrun callers allocated temp buffer */
Steve French6a0b4822005-04-28 22:41:05 -0700666 if(j >= (2 * NAME_MAX))
667 break;
668 }
669cUCS_out:
670 target[j] = 0;
671 return j;
672}
Steve French6c91d362005-04-28 22:41:06 -0700673
674/* Convert 16 bit Unicode pathname to wire format from string in current code
675 page. Conversion may involve remapping up the seven characters that are
676 only legal in POSIX-like OS (if they are present in the string). Path
677 names are little endian 16 bit Unicode on the wire */
678int
679cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
680 const struct nls_table * cp, int mapChars)
681{
682 int i,j,charlen;
683 int len_remaining = maxlen;
684 char src_char;
Steve French70ca7342005-09-22 16:32:06 -0700685 __u16 temp;
Steve French6c91d362005-04-28 22:41:06 -0700686
687 if(!mapChars)
Steve Frenche89dc922005-11-11 15:18:19 -0800688 return cifs_strtoUCS(target, source, PATH_MAX, cp);
Steve French6c91d362005-04-28 22:41:06 -0700689
690 for(i = 0, j = 0; i < maxlen; j++) {
691 src_char = source[i];
692 switch (src_char) {
693 case 0:
Steve Frenchf4cfd692005-07-14 18:29:02 -0500694 target[j] = 0;
Steve French6c91d362005-04-28 22:41:06 -0700695 goto ctoUCS_out;
696 case ':':
697 target[j] = cpu_to_le16(UNI_COLON);
698 break;
699 case '*':
700 target[j] = cpu_to_le16(UNI_ASTERIK);
701 break;
702 case '?':
703 target[j] = cpu_to_le16(UNI_QUESTION);
704 break;
705 case '<':
706 target[j] = cpu_to_le16(UNI_LESSTHAN);
707 break;
708 case '>':
709 target[j] = cpu_to_le16(UNI_GRTRTHAN);
710 break;
711 case '|':
712 target[j] = cpu_to_le16(UNI_PIPE);
713 break;
714 /* BB We can not handle remapping slash until
715 all the calls to build_path_from_dentry
716 are modified, as they use slash as separator BB */
717 /* case '\\':
718 target[j] = cpu_to_le16(UNI_SLASH);
719 break;*/
720 default:
721 charlen = cp->char2uni(source+i,
Steve French70ca7342005-09-22 16:32:06 -0700722 len_remaining, &temp);
Steve French6c91d362005-04-28 22:41:06 -0700723 /* if no match, use question mark, which
724 at least in some cases servers as wild card */
725 if(charlen < 1) {
726 target[j] = cpu_to_le16(0x003f);
727 charlen = 1;
Steve French70ca7342005-09-22 16:32:06 -0700728 } else
729 target[j] = cpu_to_le16(temp);
Steve French6c91d362005-04-28 22:41:06 -0700730 len_remaining -= charlen;
731 /* character may take more than one byte in the
732 the source string, but will take exactly two
733 bytes in the target string */
734 i+= charlen;
735 continue;
736 }
737 i++; /* move to next char in source string */
738 len_remaining--;
739 }
740
741ctoUCS_out:
742 return i;
743}