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 write_lock(&GlobalSMBSeslock);
79 atomic_inc(&sesInfoAllocCount);
80 ret_buf->status = CifsNew;
81 list_add(&ret_buf->cifsSessionList, &GlobalSMBSessionList);
82 init_MUTEX(&ret_buf->sesSem);
83 write_unlock(&GlobalSMBSeslock);
89 sesInfoFree(struct cifsSesInfo *buf_to_free)
91 if (buf_to_free == NULL) {
92 cFYI(1, ("Null buffer passed to sesInfoFree"));
96 write_lock(&GlobalSMBSeslock);
97 atomic_dec(&sesInfoAllocCount);
98 list_del(&buf_to_free->cifsSessionList);
99 write_unlock(&GlobalSMBSeslock);
100 kfree(buf_to_free->serverOS);
101 kfree(buf_to_free->serverDomain);
102 kfree(buf_to_free->serverNOS);
103 kfree(buf_to_free->password);
104 kfree(buf_to_free->domainName);
108 struct cifsTconInfo *
111 struct cifsTconInfo *ret_buf;
112 ret_buf = kzalloc(sizeof(struct cifsTconInfo), GFP_KERNEL);
114 write_lock(&GlobalSMBSeslock);
115 atomic_inc(&tconInfoAllocCount);
116 list_add(&ret_buf->cifsConnectionList,
117 &GlobalTreeConnectionList);
118 ret_buf->tidStatus = CifsNew;
119 INIT_LIST_HEAD(&ret_buf->openFileList);
120 init_MUTEX(&ret_buf->tconSem);
121 #ifdef CONFIG_CIFS_STATS
122 spin_lock_init(&ret_buf->stat_lock);
124 write_unlock(&GlobalSMBSeslock);
130 tconInfoFree(struct cifsTconInfo *buf_to_free)
132 if (buf_to_free == NULL) {
133 cFYI(1, ("Null buffer passed to tconInfoFree"));
136 write_lock(&GlobalSMBSeslock);
137 atomic_dec(&tconInfoAllocCount);
138 list_del(&buf_to_free->cifsConnectionList);
139 write_unlock(&GlobalSMBSeslock);
140 kfree(buf_to_free->nativeFileSystem);
147 struct smb_hdr *ret_buf = NULL;
149 /* We could use negotiated size instead of max_msgsize -
150 but it may be more efficient to always alloc same size
151 albeit slightly larger than necessary and maxbuffersize
152 defaults to this and can not be bigger */
153 ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
155 /* clear the first few header bytes */
156 /* for most paths, more is cleared in header_assemble */
158 memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
159 atomic_inc(&bufAllocCount);
160 #ifdef CONFIG_CIFS_STATS2
161 atomic_inc(&totBufAllocCount);
162 #endif /* CONFIG_CIFS_STATS2 */
169 cifs_buf_release(void *buf_to_free)
171 if (buf_to_free == NULL) {
172 /* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/
175 mempool_free(buf_to_free, cifs_req_poolp);
177 atomic_dec(&bufAllocCount);
182 cifs_small_buf_get(void)
184 struct smb_hdr *ret_buf = NULL;
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 = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
192 /* No need to clear memory here, cleared in header assemble */
193 /* memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
194 atomic_inc(&smBufAllocCount);
195 #ifdef CONFIG_CIFS_STATS2
196 atomic_inc(&totSmBufAllocCount);
197 #endif /* CONFIG_CIFS_STATS2 */
204 cifs_small_buf_release(void *buf_to_free)
207 if (buf_to_free == NULL) {
208 cFYI(1, ("Null buffer passed to cifs_small_buf_release"));
211 mempool_free(buf_to_free, cifs_sm_req_poolp);
213 atomic_dec(&smBufAllocCount);
218 Find a free multiplex id (SMB mid). Otherwise there could be
219 mid collisions which might cause problems, demultiplexing the
220 wrong response to this request. Multiplex ids could collide if
221 one of a series requests takes much longer than the others, or
222 if a very large number of long lived requests (byte range
223 locks or FindNotify requests) are pending. No more than
224 64K-1 requests can be outstanding at one time. If no
225 mids are available, return zero. A future optimization
226 could make the combination of mids and uid the key we use
227 to demultiplex on (rather than mid alone).
228 In addition to the above check, the cifs demultiplex
229 code already used the command code as a secondary
230 check of the frame and if signing is negotiated the
231 response would be discarded if the mid were the same
232 but the signature was wrong. Since the mid is not put in the
233 pending queue until later (when it is about to be dispatched)
234 we do have to limit the number of outstanding requests
235 to somewhat less than 64K-1 although it is hard to imagine
236 so many threads being in the vfs at one time.
238 __u16 GetNextMid(struct TCP_Server_Info *server)
247 spin_lock(&GlobalMid_Lock);
248 last_mid = server->CurrentMid; /* we do not want to loop forever */
249 server->CurrentMid++;
250 /* This nested loop looks more expensive than it is.
251 In practice the list of pending requests is short,
252 fewer than 50, and the mids are likely to be unique
253 on the first pass through the loop unless some request
254 takes longer than the 64 thousand requests before it
255 (and it would also have to have been a request that
257 while (server->CurrentMid != last_mid) {
258 struct list_head *tmp;
259 struct mid_q_entry *mid_entry;
262 if (server->CurrentMid == 0)
263 server->CurrentMid++;
265 list_for_each(tmp, &server->pending_mid_q) {
266 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
268 if ((mid_entry->mid == server->CurrentMid) &&
269 (mid_entry->midState == MID_REQUEST_SUBMITTED)) {
270 /* This mid is in use, try a different one */
275 if (collision == 0) {
276 mid = server->CurrentMid;
279 server->CurrentMid++;
281 spin_unlock(&GlobalMid_Lock);
285 /* NB: MID can not be set if treeCon not passed in, in that
286 case it is responsbility of caller to set the mid */
288 header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
289 const struct cifsTconInfo *treeCon, int word_count
290 /* length of fixed section (word count) in two byte units */)
292 struct list_head *temp_item;
293 struct cifsSesInfo *ses;
294 char *temp = (char *) buffer;
296 memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
298 buffer->smb_buf_length =
299 (2 * word_count) + sizeof(struct smb_hdr) -
300 4 /* RFC 1001 length field does not count */ +
301 2 /* for bcc field itself */ ;
302 /* Note that this is the only network field that has to be converted
303 to big endian and it is done just before we send it */
305 buffer->Protocol[0] = 0xFF;
306 buffer->Protocol[1] = 'S';
307 buffer->Protocol[2] = 'M';
308 buffer->Protocol[3] = 'B';
309 buffer->Command = smb_command;
310 buffer->Flags = 0x00; /* case sensitive */
311 buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
312 buffer->Pid = cpu_to_le16((__u16)current->tgid);
313 buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
314 spin_lock(&GlobalMid_Lock);
315 spin_unlock(&GlobalMid_Lock);
317 buffer->Tid = treeCon->tid;
319 if (treeCon->ses->capabilities & CAP_UNICODE)
320 buffer->Flags2 |= SMBFLG2_UNICODE;
321 if (treeCon->ses->capabilities & CAP_STATUS32)
322 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
324 /* Uid is not converted */
325 buffer->Uid = treeCon->ses->Suid;
326 buffer->Mid = GetNextMid(treeCon->ses->server);
327 if (multiuser_mount != 0) {
328 /* For the multiuser case, there are few obvious technically */
329 /* possible mechanisms to match the local linux user (uid) */
330 /* to a valid remote smb user (smb_uid): */
331 /* 1) Query Winbind (or other local pam/nss daemon */
332 /* for userid/password/logon_domain or credential */
333 /* 2) Query Winbind for uid to sid to username mapping */
334 /* and see if we have a matching password for existing*/
335 /* session for that user perhas getting password by */
336 /* adding a new pam_cifs module that stores passwords */
337 /* so that the cifs vfs can get at that for all logged*/
339 /* 3) (Which is the mechanism we have chosen) */
340 /* Search through sessions to the same server for a */
341 /* a match on the uid that was passed in on mount */
342 /* with the current processes uid (or euid?) and use */
343 /* that smb uid. If no existing smb session for */
344 /* that uid found, use the default smb session ie */
345 /* the smb session for the volume mounted which is */
346 /* the same as would be used if the multiuser mount */
347 /* flag were disabled. */
349 /* BB Add support for establishing new tCon and SMB Session */
350 /* with userid/password pairs found on the smb session */
351 /* for other target tcp/ip addresses BB */
352 if (current->fsuid != treeCon->ses->linux_uid) {
353 cFYI(1, ("Multiuser mode and UID "
354 "did not match tcon uid"));
355 read_lock(&GlobalSMBSeslock);
356 list_for_each(temp_item, &GlobalSMBSessionList) {
357 ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList);
358 if (ses->linux_uid == current->fsuid) {
359 if (ses->server == treeCon->ses->server) {
360 cFYI(1, ("found matching uid substitute right smb_uid"));
361 buffer->Uid = ses->Suid;
364 /* BB eventually call cifs_setup_session here */
365 cFYI(1, ("local UID found but no smb sess with this server exists"));
369 read_unlock(&GlobalSMBSeslock);
373 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
374 buffer->Flags2 |= SMBFLG2_DFS;
376 buffer->Flags |= SMBFLG_CASELESS;
377 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;
383 /* endian conversion of flags is now done just before sending */
384 buffer->WordCount = (char) word_count;
389 checkSMBhdr(struct smb_hdr *smb, __u16 mid)
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)) &&
395 if (smb->Flags & SMBFLG_RESPONSE)
398 /* only one valid case where server sends us request */
399 if (smb->Command == SMB_COM_LOCKING_ANDX)
402 cERROR(1, ("Received Request not response"));
404 } else { /* bad signature or mid */
405 if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
407 ("Bad protocol string signature header %x",
408 *(unsigned int *) smb->Protocol));
410 cERROR(1, ("Mids do not match"));
412 cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid));
417 checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
419 __u32 len = smb->smb_buf_length;
420 __u32 clc_len; /* calculated length */
421 cFYI(0, ("checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len));
423 if (length < 2 + sizeof(struct smb_hdr)) {
424 if ((length >= sizeof(struct smb_hdr) - 1)
425 && (smb->Status.CifsError != 0)) {
427 /* some error cases do not return wct and bcc */
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
441 /* zero rest of bcc */
442 tmp[sizeof(struct smb_hdr)+1] = 0;
445 cERROR(1, ("rcvd invalid byte count (bcc)"));
447 cERROR(1, ("Length less than smb header size"));
451 if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
452 cERROR(1, ("smb length greater than MaxBufSize, mid=%d",
457 if (checkSMBhdr(smb, mid))
459 clc_len = smbCalcSize_LE(smb);
461 if (4 + len != length) {
462 cERROR(1, ("Length read does not match RFC1001 length %d",
467 if (4 + len != clc_len) {
468 /* check if bcc wrapped around for large read responses */
469 if ((len > 64 * 1024) && (len > clc_len)) {
470 /* check if lengths match mod 64K */
471 if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
472 return 0; /* bcc wrapped */
474 cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
475 clc_len, 4 + len, smb->Mid));
476 /* Windows XP can return a few bytes too much, presumably
477 an illegal pad, at the end of byte range lock responses
478 so we allow for that three byte pad, as long as actual
479 received length is as long or longer than calculated length */
480 /* We have now had to extend this more, since there is a
481 case in which it needs to be bigger still to handle a
482 malformed response to transact2 findfirst from WinXP when
483 access denied is returned and thus bcc and wct are zero
484 but server says length is 0x21 bytes too long as if the server
485 forget to reset the smb rfc1001 length when it reset the
486 wct and bcc to minimum size and drop the t2 parms and data */
487 if ((4+len > clc_len) && (len <= clc_len + 512))
490 cERROR(1, ("RFC1001 size %d bigger than SMB for Mid=%d",
499 is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
501 struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
502 struct list_head *tmp;
503 struct list_head *tmp1;
504 struct cifsTconInfo *tcon;
505 struct cifsFileInfo *netfile;
507 cFYI(1, ("Checking for oplock break or dnotify response"));
508 if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
509 (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
510 struct smb_com_transaction_change_notify_rsp *pSMBr =
511 (struct smb_com_transaction_change_notify_rsp *)buf;
512 struct file_notify_information *pnotify;
513 __u32 data_offset = 0;
514 if (pSMBr->ByteCount > sizeof(struct file_notify_information)) {
515 data_offset = le32_to_cpu(pSMBr->DataOffset);
517 pnotify = (struct file_notify_information *)
518 ((char *)&pSMBr->hdr.Protocol + data_offset);
519 cFYI(1, ("dnotify on %s Action: 0x%x",
520 pnotify->FileName, pnotify->Action));
521 /* cifs_dump_mem("Rcvd notify Data: ",buf,
522 sizeof(struct smb_hdr)+60); */
525 if (pSMBr->hdr.Status.CifsError) {
526 cFYI(1, ("notify err 0x%d",
527 pSMBr->hdr.Status.CifsError));
532 if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
534 if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
535 /* no sense logging error on invalid handle on oplock
536 break - harmless race between close request and oplock
537 break response is expected from time to time writing out
538 large dirty files cached on the client */
539 if ((NT_STATUS_INVALID_HANDLE) ==
540 le32_to_cpu(pSMB->hdr.Status.CifsError)) {
541 cFYI(1, ("invalid handle on oplock break"));
543 } else if (ERRbadfid ==
544 le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
547 return false; /* on valid oplock brk we get "request" */
550 if (pSMB->hdr.WordCount != 8)
553 cFYI(1, ("oplock type 0x%d level 0x%d",
554 pSMB->LockType, pSMB->OplockLevel));
555 if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
558 /* look up tcon based on tid & uid */
559 read_lock(&GlobalSMBSeslock);
560 list_for_each(tmp, &GlobalTreeConnectionList) {
561 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
562 if ((tcon->tid == buf->Tid) && (srv == tcon->ses->server)) {
563 cifs_stats_inc(&tcon->num_oplock_brks);
564 list_for_each(tmp1, &tcon->openFileList) {
565 netfile = list_entry(tmp1, struct cifsFileInfo,
567 if (pSMB->Fid == netfile->netfid) {
568 struct cifsInodeInfo *pCifsInode;
569 read_unlock(&GlobalSMBSeslock);
571 ("file id match, oplock break"));
573 CIFS_I(netfile->pInode);
574 pCifsInode->clientCanCacheAll = false;
575 if (pSMB->OplockLevel == 0)
576 pCifsInode->clientCanCacheRead
578 pCifsInode->oplockPending = true;
579 AllocOplockQEntry(netfile->pInode,
583 ("about to wake up oplock thread"));
585 wake_up_process(oplockThread);
589 read_unlock(&GlobalSMBSeslock);
590 cFYI(1, ("No matching file for oplock break"));
594 read_unlock(&GlobalSMBSeslock);
595 cFYI(1, ("Can not process oplock break for non-existent connection"));
600 dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
604 unsigned char *buffer;
609 buffer = (unsigned char *) smb_buf;
610 for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
612 /* have reached the beginning of line */
613 printk(KERN_DEBUG "| ");
616 printk("%0#4x ", buffer[i]);
617 debug_line[2 * j] = ' ';
618 if (isprint(buffer[i]))
619 debug_line[1 + (2 * j)] = buffer[i];
621 debug_line[1 + (2 * j)] = '_';
624 /* reached end of line, time to print ascii */
626 printk(" | %s\n", debug_line);
631 debug_line[2 * j] = ' ';
632 debug_line[1 + (2 * j)] = ' ';
634 printk(" | %s\n", debug_line);
638 /* Windows maps these to the user defined 16 bit Unicode range since they are
639 reserved symbols (along with \ and /), otherwise illegal to store
640 in filenames in NTFS */
641 #define UNI_ASTERIK (__u16) ('*' + 0xF000)
642 #define UNI_QUESTION (__u16) ('?' + 0xF000)
643 #define UNI_COLON (__u16) (':' + 0xF000)
644 #define UNI_GRTRTHAN (__u16) ('>' + 0xF000)
645 #define UNI_LESSTHAN (__u16) ('<' + 0xF000)
646 #define UNI_PIPE (__u16) ('|' + 0xF000)
647 #define UNI_SLASH (__u16) ('\\' + 0xF000)
649 /* Convert 16 bit Unicode pathname from wire format to string in current code
650 page. Conversion may involve remapping up the seven characters that are
651 only legal in POSIX-like OS (if they are present in the string). Path
652 names are little endian 16 bit Unicode on the wire */
654 cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
655 const struct nls_table *cp)
660 for (i = 0, j = 0; i < maxlen; i++) {
661 src_char = le16_to_cpu(source[i]);
664 goto cUCS_out; /* BB check this BB */
674 /* BB We can not handle remapping slash until
675 all the calls to build_path_from_dentry
676 are modified, as they use slash as separator BB */
690 len = cp->uni2char(src_char, &target[j],
691 NLS_MAX_CHARSET_SIZE);
700 /* make sure we do not overrun callers allocated temp buffer */
701 if (j >= (2 * NAME_MAX))
709 /* Convert 16 bit Unicode pathname to wire format from string in current code
710 page. Conversion may involve remapping up the seven characters that are
711 only legal in POSIX-like OS (if they are present in the string). Path
712 names are little endian 16 bit Unicode on the wire */
714 cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
715 const struct nls_table *cp, int mapChars)
718 int len_remaining = maxlen;
723 return cifs_strtoUCS(target, source, PATH_MAX, cp);
725 for (i = 0, j = 0; i < maxlen; j++) {
726 src_char = source[i];
732 target[j] = cpu_to_le16(UNI_COLON);
735 target[j] = cpu_to_le16(UNI_ASTERIK);
738 target[j] = cpu_to_le16(UNI_QUESTION);
741 target[j] = cpu_to_le16(UNI_LESSTHAN);
744 target[j] = cpu_to_le16(UNI_GRTRTHAN);
747 target[j] = cpu_to_le16(UNI_PIPE);
749 /* BB We can not handle remapping slash until
750 all the calls to build_path_from_dentry
751 are modified, as they use slash as separator BB */
753 target[j] = cpu_to_le16(UNI_SLASH);
756 charlen = cp->char2uni(source+i,
757 len_remaining, &temp);
758 /* if no match, use question mark, which
759 at least in some cases servers as wild card */
761 target[j] = cpu_to_le16(0x003f);
764 target[j] = cpu_to_le16(temp);
765 len_remaining -= charlen;
766 /* character may take more than one byte in the
767 the source string, but will take exactly two
768 bytes in the target string */
772 i++; /* move to next char in source string */