4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
22 #include <linux/slab.h>
23 #include <linux/ctype.h>
24 #include <linux/mempool.h>
27 #include "cifsproto.h"
28 #include "cifs_debug.h"
31 #include "cifs_unicode.h"
33 extern mempool_t *cifs_sm_req_poolp;
34 extern mempool_t *cifs_req_poolp;
35 extern struct task_struct *oplockThread;
37 /* 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 */
48 spin_lock(&GlobalMid_Lock);
49 GlobalTotalActiveXid++;
51 /* keep high water mark for number of simultaneous ops in filesystem */
52 if (GlobalTotalActiveXid > GlobalMaxActiveXid)
53 GlobalMaxActiveXid = GlobalTotalActiveXid;
54 if (GlobalTotalActiveXid > 65000)
55 cFYI(1, ("warning: more than 65000 requests active"));
56 xid = GlobalCurrentXid++;
57 spin_unlock(&GlobalMid_Lock);
62 _FreeXid(unsigned int xid)
64 spin_lock(&GlobalMid_Lock);
65 /* if (GlobalTotalActiveXid == 0)
67 GlobalTotalActiveXid--;
68 spin_unlock(&GlobalMid_Lock);
74 struct cifsSesInfo *ret_buf;
76 ret_buf = kzalloc(sizeof(struct cifsSesInfo), GFP_KERNEL);
78 atomic_inc(&sesInfoAllocCount);
79 ret_buf->status = CifsNew;
81 INIT_LIST_HEAD(&ret_buf->smb_ses_list);
82 init_MUTEX(&ret_buf->sesSem);
88 sesInfoFree(struct cifsSesInfo *buf_to_free)
90 if (buf_to_free == NULL) {
91 cFYI(1, ("Null buffer passed to sesInfoFree"));
95 atomic_dec(&sesInfoAllocCount);
96 kfree(buf_to_free->serverOS);
97 kfree(buf_to_free->serverDomain);
98 kfree(buf_to_free->serverNOS);
99 kfree(buf_to_free->password);
100 kfree(buf_to_free->domainName);
104 struct cifsTconInfo *
107 struct cifsTconInfo *ret_buf;
108 ret_buf = kzalloc(sizeof(struct cifsTconInfo), GFP_KERNEL);
110 write_lock(&GlobalSMBSeslock);
111 atomic_inc(&tconInfoAllocCount);
112 list_add(&ret_buf->cifsConnectionList,
113 &GlobalTreeConnectionList);
114 ret_buf->tidStatus = CifsNew;
115 INIT_LIST_HEAD(&ret_buf->openFileList);
116 init_MUTEX(&ret_buf->tconSem);
117 #ifdef CONFIG_CIFS_STATS
118 spin_lock_init(&ret_buf->stat_lock);
120 write_unlock(&GlobalSMBSeslock);
126 tconInfoFree(struct cifsTconInfo *buf_to_free)
128 if (buf_to_free == NULL) {
129 cFYI(1, ("Null buffer passed to tconInfoFree"));
132 write_lock(&GlobalSMBSeslock);
133 atomic_dec(&tconInfoAllocCount);
134 list_del(&buf_to_free->cifsConnectionList);
135 write_unlock(&GlobalSMBSeslock);
136 kfree(buf_to_free->nativeFileSystem);
143 struct smb_hdr *ret_buf = NULL;
145 /* We could use negotiated size instead of max_msgsize -
146 but it may be more efficient to always alloc same size
147 albeit slightly larger than necessary and maxbuffersize
148 defaults to this and can not be bigger */
149 ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
151 /* clear the first few header bytes */
152 /* for most paths, more is cleared in header_assemble */
154 memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
155 atomic_inc(&bufAllocCount);
156 #ifdef CONFIG_CIFS_STATS2
157 atomic_inc(&totBufAllocCount);
158 #endif /* CONFIG_CIFS_STATS2 */
165 cifs_buf_release(void *buf_to_free)
167 if (buf_to_free == NULL) {
168 /* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/
171 mempool_free(buf_to_free, cifs_req_poolp);
173 atomic_dec(&bufAllocCount);
178 cifs_small_buf_get(void)
180 struct smb_hdr *ret_buf = NULL;
182 /* We could use negotiated size instead of max_msgsize -
183 but it may be more efficient to always alloc same size
184 albeit slightly larger than necessary and maxbuffersize
185 defaults to this and can not be bigger */
186 ret_buf = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
188 /* No need to clear memory here, cleared in header assemble */
189 /* memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
190 atomic_inc(&smBufAllocCount);
191 #ifdef CONFIG_CIFS_STATS2
192 atomic_inc(&totSmBufAllocCount);
193 #endif /* CONFIG_CIFS_STATS2 */
200 cifs_small_buf_release(void *buf_to_free)
203 if (buf_to_free == NULL) {
204 cFYI(1, ("Null buffer passed to cifs_small_buf_release"));
207 mempool_free(buf_to_free, cifs_sm_req_poolp);
209 atomic_dec(&smBufAllocCount);
214 Find a free multiplex id (SMB mid). Otherwise there could be
215 mid collisions which might cause problems, demultiplexing the
216 wrong response to this request. Multiplex ids could collide if
217 one of a series requests takes much longer than the others, or
218 if a very large number of long lived requests (byte range
219 locks or FindNotify requests) are pending. No more than
220 64K-1 requests can be outstanding at one time. If no
221 mids are available, return zero. A future optimization
222 could make the combination of mids and uid the key we use
223 to demultiplex on (rather than mid alone).
224 In addition to the above check, the cifs demultiplex
225 code already used the command code as a secondary
226 check of the frame and if signing is negotiated the
227 response would be discarded if the mid were the same
228 but the signature was wrong. Since the mid is not put in the
229 pending queue until later (when it is about to be dispatched)
230 we do have to limit the number of outstanding requests
231 to somewhat less than 64K-1 although it is hard to imagine
232 so many threads being in the vfs at one time.
234 __u16 GetNextMid(struct TCP_Server_Info *server)
243 spin_lock(&GlobalMid_Lock);
244 last_mid = server->CurrentMid; /* we do not want to loop forever */
245 server->CurrentMid++;
246 /* This nested loop looks more expensive than it is.
247 In practice the list of pending requests is short,
248 fewer than 50, and the mids are likely to be unique
249 on the first pass through the loop unless some request
250 takes longer than the 64 thousand requests before it
251 (and it would also have to have been a request that
253 while (server->CurrentMid != last_mid) {
254 struct list_head *tmp;
255 struct mid_q_entry *mid_entry;
258 if (server->CurrentMid == 0)
259 server->CurrentMid++;
261 list_for_each(tmp, &server->pending_mid_q) {
262 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
264 if ((mid_entry->mid == server->CurrentMid) &&
265 (mid_entry->midState == MID_REQUEST_SUBMITTED)) {
266 /* This mid is in use, try a different one */
271 if (collision == 0) {
272 mid = server->CurrentMid;
275 server->CurrentMid++;
277 spin_unlock(&GlobalMid_Lock);
281 /* NB: MID can not be set if treeCon not passed in, in that
282 case it is responsbility of caller to set the mid */
284 header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
285 const struct cifsTconInfo *treeCon, int word_count
286 /* length of fixed section (word count) in two byte units */)
288 struct list_head *temp_item;
289 struct cifsSesInfo *ses;
290 char *temp = (char *) buffer;
292 memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
294 buffer->smb_buf_length =
295 (2 * word_count) + sizeof(struct smb_hdr) -
296 4 /* RFC 1001 length field does not count */ +
297 2 /* for bcc field itself */ ;
298 /* Note that this is the only network field that has to be converted
299 to big endian and it is done just before we send it */
301 buffer->Protocol[0] = 0xFF;
302 buffer->Protocol[1] = 'S';
303 buffer->Protocol[2] = 'M';
304 buffer->Protocol[3] = 'B';
305 buffer->Command = smb_command;
306 buffer->Flags = 0x00; /* case sensitive */
307 buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
308 buffer->Pid = cpu_to_le16((__u16)current->tgid);
309 buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
311 buffer->Tid = treeCon->tid;
313 if (treeCon->ses->capabilities & CAP_UNICODE)
314 buffer->Flags2 |= SMBFLG2_UNICODE;
315 if (treeCon->ses->capabilities & CAP_STATUS32)
316 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
318 /* Uid is not converted */
319 buffer->Uid = treeCon->ses->Suid;
320 buffer->Mid = GetNextMid(treeCon->ses->server);
321 if (multiuser_mount != 0) {
322 /* For the multiuser case, there are few obvious technically */
323 /* possible mechanisms to match the local linux user (uid) */
324 /* to a valid remote smb user (smb_uid): */
325 /* 1) Query Winbind (or other local pam/nss daemon */
326 /* for userid/password/logon_domain or credential */
327 /* 2) Query Winbind for uid to sid to username mapping */
328 /* and see if we have a matching password for existing*/
329 /* session for that user perhas getting password by */
330 /* adding a new pam_cifs module that stores passwords */
331 /* so that the cifs vfs can get at that for all logged*/
333 /* 3) (Which is the mechanism we have chosen) */
334 /* Search through sessions to the same server for a */
335 /* a match on the uid that was passed in on mount */
336 /* with the current processes uid (or euid?) and use */
337 /* that smb uid. If no existing smb session for */
338 /* that uid found, use the default smb session ie */
339 /* the smb session for the volume mounted which is */
340 /* the same as would be used if the multiuser mount */
341 /* flag were disabled. */
343 /* BB Add support for establishing new tCon and SMB Session */
344 /* with userid/password pairs found on the smb session */
345 /* for other target tcp/ip addresses BB */
346 if (current->fsuid != treeCon->ses->linux_uid) {
347 cFYI(1, ("Multiuser mode and UID "
348 "did not match tcon uid"));
349 read_lock(&cifs_tcp_ses_lock);
350 list_for_each(temp_item, &treeCon->ses->server->smb_ses_list) {
351 ses = list_entry(temp_item, struct cifsSesInfo, smb_ses_list);
352 if (ses->linux_uid == current->fsuid) {
353 if (ses->server == treeCon->ses->server) {
354 cFYI(1, ("found matching uid substitute right smb_uid"));
355 buffer->Uid = ses->Suid;
358 /* BB eventually call cifs_setup_session here */
359 cFYI(1, ("local UID found but no smb sess with this server exists"));
363 read_unlock(&cifs_tcp_ses_lock);
367 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
368 buffer->Flags2 |= SMBFLG2_DFS;
370 buffer->Flags |= SMBFLG_CASELESS;
371 if ((treeCon->ses) && (treeCon->ses->server))
372 if (treeCon->ses->server->secMode &
373 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
374 buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
377 /* endian conversion of flags is now done just before sending */
378 buffer->WordCount = (char) word_count;
383 checkSMBhdr(struct smb_hdr *smb, __u16 mid)
385 /* Make sure that this really is an SMB, that it is a response,
386 and that the message ids match */
387 if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
389 if (smb->Flags & SMBFLG_RESPONSE)
392 /* only one valid case where server sends us request */
393 if (smb->Command == SMB_COM_LOCKING_ANDX)
396 cERROR(1, ("Received Request not response"));
398 } else { /* bad signature or mid */
399 if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
401 ("Bad protocol string signature header %x",
402 *(unsigned int *) smb->Protocol));
404 cERROR(1, ("Mids do not match"));
406 cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid));
411 checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
413 __u32 len = smb->smb_buf_length;
414 __u32 clc_len; /* calculated length */
415 cFYI(0, ("checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len));
417 if (length < 2 + sizeof(struct smb_hdr)) {
418 if ((length >= sizeof(struct smb_hdr) - 1)
419 && (smb->Status.CifsError != 0)) {
421 /* some error cases do not return wct and bcc */
423 } else if ((length == sizeof(struct smb_hdr) + 1) &&
424 (smb->WordCount == 0)) {
425 char *tmp = (char *)smb;
426 /* Need to work around a bug in two servers here */
427 /* First, check if the part of bcc they sent was zero */
428 if (tmp[sizeof(struct smb_hdr)] == 0) {
429 /* some servers return only half of bcc
430 * on simple responses (wct, bcc both zero)
431 * in particular have seen this on
432 * ulogoffX and FindClose. This leaves
433 * one byte of bcc potentially unitialized
435 /* zero rest of bcc */
436 tmp[sizeof(struct smb_hdr)+1] = 0;
439 cERROR(1, ("rcvd invalid byte count (bcc)"));
441 cERROR(1, ("Length less than smb header size"));
445 if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
446 cERROR(1, ("smb length greater than MaxBufSize, mid=%d",
451 if (checkSMBhdr(smb, mid))
453 clc_len = smbCalcSize_LE(smb);
455 if (4 + len != length) {
456 cERROR(1, ("Length read does not match RFC1001 length %d",
461 if (4 + len != clc_len) {
462 /* check if bcc wrapped around for large read responses */
463 if ((len > 64 * 1024) && (len > clc_len)) {
464 /* check if lengths match mod 64K */
465 if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
466 return 0; /* bcc wrapped */
468 cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
469 clc_len, 4 + len, smb->Mid));
470 /* Windows XP can return a few bytes too much, presumably
471 an illegal pad, at the end of byte range lock responses
472 so we allow for that three byte pad, as long as actual
473 received length is as long or longer than calculated length */
474 /* We have now had to extend this more, since there is a
475 case in which it needs to be bigger still to handle a
476 malformed response to transact2 findfirst from WinXP when
477 access denied is returned and thus bcc and wct are zero
478 but server says length is 0x21 bytes too long as if the server
479 forget to reset the smb rfc1001 length when it reset the
480 wct and bcc to minimum size and drop the t2 parms and data */
481 if ((4+len > clc_len) && (len <= clc_len + 512))
484 cERROR(1, ("RFC1001 size %d bigger than SMB for Mid=%d",
493 is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
495 struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
496 struct list_head *tmp;
497 struct list_head *tmp1;
498 struct cifsTconInfo *tcon;
499 struct cifsFileInfo *netfile;
501 cFYI(1, ("Checking for oplock break or dnotify response"));
502 if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
503 (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
504 struct smb_com_transaction_change_notify_rsp *pSMBr =
505 (struct smb_com_transaction_change_notify_rsp *)buf;
506 struct file_notify_information *pnotify;
507 __u32 data_offset = 0;
508 if (pSMBr->ByteCount > sizeof(struct file_notify_information)) {
509 data_offset = le32_to_cpu(pSMBr->DataOffset);
511 pnotify = (struct file_notify_information *)
512 ((char *)&pSMBr->hdr.Protocol + data_offset);
513 cFYI(1, ("dnotify on %s Action: 0x%x",
514 pnotify->FileName, pnotify->Action));
515 /* cifs_dump_mem("Rcvd notify Data: ",buf,
516 sizeof(struct smb_hdr)+60); */
519 if (pSMBr->hdr.Status.CifsError) {
520 cFYI(1, ("notify err 0x%d",
521 pSMBr->hdr.Status.CifsError));
526 if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
528 if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
529 /* no sense logging error on invalid handle on oplock
530 break - harmless race between close request and oplock
531 break response is expected from time to time writing out
532 large dirty files cached on the client */
533 if ((NT_STATUS_INVALID_HANDLE) ==
534 le32_to_cpu(pSMB->hdr.Status.CifsError)) {
535 cFYI(1, ("invalid handle on oplock break"));
537 } else if (ERRbadfid ==
538 le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
541 return false; /* on valid oplock brk we get "request" */
544 if (pSMB->hdr.WordCount != 8)
547 cFYI(1, ("oplock type 0x%d level 0x%d",
548 pSMB->LockType, pSMB->OplockLevel));
549 if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
552 /* look up tcon based on tid & uid */
553 read_lock(&GlobalSMBSeslock);
554 list_for_each(tmp, &GlobalTreeConnectionList) {
555 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
556 if ((tcon->tid == buf->Tid) && (srv == tcon->ses->server)) {
557 cifs_stats_inc(&tcon->num_oplock_brks);
558 list_for_each(tmp1, &tcon->openFileList) {
559 netfile = list_entry(tmp1, struct cifsFileInfo,
561 if (pSMB->Fid == netfile->netfid) {
562 struct cifsInodeInfo *pCifsInode;
563 read_unlock(&GlobalSMBSeslock);
565 ("file id match, oplock break"));
567 CIFS_I(netfile->pInode);
568 pCifsInode->clientCanCacheAll = false;
569 if (pSMB->OplockLevel == 0)
570 pCifsInode->clientCanCacheRead
572 pCifsInode->oplockPending = true;
573 AllocOplockQEntry(netfile->pInode,
577 ("about to wake up oplock thread"));
579 wake_up_process(oplockThread);
583 read_unlock(&GlobalSMBSeslock);
584 cFYI(1, ("No matching file for oplock break"));
588 read_unlock(&GlobalSMBSeslock);
589 cFYI(1, ("Can not process oplock break for non-existent connection"));
594 dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
598 unsigned char *buffer;
603 buffer = (unsigned char *) smb_buf;
604 for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
606 /* have reached the beginning of line */
607 printk(KERN_DEBUG "| ");
610 printk("%0#4x ", buffer[i]);
611 debug_line[2 * j] = ' ';
612 if (isprint(buffer[i]))
613 debug_line[1 + (2 * j)] = buffer[i];
615 debug_line[1 + (2 * j)] = '_';
618 /* reached end of line, time to print ascii */
620 printk(" | %s\n", debug_line);
625 debug_line[2 * j] = ' ';
626 debug_line[1 + (2 * j)] = ' ';
628 printk(" | %s\n", debug_line);
632 /* Windows maps these to the user defined 16 bit Unicode range since they are
633 reserved symbols (along with \ and /), otherwise illegal to store
634 in filenames in NTFS */
635 #define UNI_ASTERIK (__u16) ('*' + 0xF000)
636 #define UNI_QUESTION (__u16) ('?' + 0xF000)
637 #define UNI_COLON (__u16) (':' + 0xF000)
638 #define UNI_GRTRTHAN (__u16) ('>' + 0xF000)
639 #define UNI_LESSTHAN (__u16) ('<' + 0xF000)
640 #define UNI_PIPE (__u16) ('|' + 0xF000)
641 #define UNI_SLASH (__u16) ('\\' + 0xF000)
643 /* Convert 16 bit Unicode pathname from wire format to string in current code
644 page. Conversion may involve remapping up the seven characters that are
645 only legal in POSIX-like OS (if they are present in the string). Path
646 names are little endian 16 bit Unicode on the wire */
648 cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
649 const struct nls_table *cp)
654 for (i = 0, j = 0; i < maxlen; i++) {
655 src_char = le16_to_cpu(source[i]);
658 goto cUCS_out; /* BB check this BB */
668 /* BB We can not handle remapping slash until
669 all the calls to build_path_from_dentry
670 are modified, as they use slash as separator BB */
684 len = cp->uni2char(src_char, &target[j],
685 NLS_MAX_CHARSET_SIZE);
694 /* make sure we do not overrun callers allocated temp buffer */
695 if (j >= (2 * NAME_MAX))
703 /* Convert 16 bit Unicode pathname to wire format from string in current code
704 page. Conversion may involve remapping up the seven characters that are
705 only legal in POSIX-like OS (if they are present in the string). Path
706 names are little endian 16 bit Unicode on the wire */
708 cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
709 const struct nls_table *cp, int mapChars)
712 int len_remaining = maxlen;
717 return cifs_strtoUCS(target, source, PATH_MAX, cp);
719 for (i = 0, j = 0; i < maxlen; j++) {
720 src_char = source[i];
726 target[j] = cpu_to_le16(UNI_COLON);
729 target[j] = cpu_to_le16(UNI_ASTERIK);
732 target[j] = cpu_to_le16(UNI_QUESTION);
735 target[j] = cpu_to_le16(UNI_LESSTHAN);
738 target[j] = cpu_to_le16(UNI_GRTRTHAN);
741 target[j] = cpu_to_le16(UNI_PIPE);
743 /* BB We can not handle remapping slash until
744 all the calls to build_path_from_dentry
745 are modified, as they use slash as separator BB */
747 target[j] = cpu_to_le16(UNI_SLASH);
750 charlen = cp->char2uni(source+i,
751 len_remaining, &temp);
752 /* if no match, use question mark, which
753 at least in some cases servers as wild card */
755 target[j] = cpu_to_le16(0x003f);
758 target[j] = cpu_to_le16(temp);
759 len_remaining -= charlen;
760 /* character may take more than one byte in the
761 the source string, but will take exactly two
762 bytes in the target string */
766 i++; /* move to next char in source string */