4 * Copyright (C) International Business Machines Corp., 2002,2009
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/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
49 #include "rfc1002pdu.h"
53 #define RFC1001_PORT 139
55 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
58 extern mempool_t *cifs_req_poolp;
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[16]; /* netbios name of client */
68 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
82 bool no_psx_acl:1; /* set if posix acl support should be disabled */
84 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
85 bool server_ino:1; /* use inode numbers from server ie UniqueId */
87 bool remap:1; /* set to remap seven reserved chars in filenames */
88 bool posix_paths:1; /* unset to not ask for posix pathnames. */
91 bool nullauth:1; /* attempt to authenticate with null user */
92 bool nocase:1; /* request case insensitive filenames */
93 bool nobrl:1; /* disable sending byte range locks to srv */
94 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
95 bool seal:1; /* request transport encryption on share */
96 bool nodfs:1; /* Do not request DFS, even if available */
97 bool local_lease:1; /* check leases only on local system, not remote */
100 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
101 bool fsc:1; /* enable fscache */
102 bool mfsymlinks:1; /* use Minshall+French Symlinks */
106 bool sockopt_tcp_nodelay:1;
107 unsigned short int port;
109 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
110 struct nls_table *local_nls;
113 /* FIXME: should these be tunable? */
114 #define TLINK_ERROR_EXPIRE (1 * HZ)
115 #define TLINK_IDLE_EXPIRE (600 * HZ)
117 static int ipv4_connect(struct TCP_Server_Info *server);
118 static int ipv6_connect(struct TCP_Server_Info *server);
119 static void cifs_prune_tlinks(struct work_struct *work);
122 * cifs tcp session reconnection
124 * mark tcp session as reconnecting so temporarily locked
125 * mark all smb sessions as reconnecting for tcp session
126 * reconnect tcp session
127 * wake up waiters on reconnection? - (not needed currently)
130 cifs_reconnect(struct TCP_Server_Info *server)
133 struct list_head *tmp, *tmp2;
134 struct cifsSesInfo *ses;
135 struct cifsTconInfo *tcon;
136 struct mid_q_entry *mid_entry;
138 spin_lock(&GlobalMid_Lock);
139 if (server->tcpStatus == CifsExiting) {
140 /* the demux thread will exit normally
141 next time through the loop */
142 spin_unlock(&GlobalMid_Lock);
145 server->tcpStatus = CifsNeedReconnect;
146 spin_unlock(&GlobalMid_Lock);
149 cFYI(1, "Reconnecting tcp session");
151 /* before reconnecting the tcp session, mark the smb session (uid)
152 and the tid bad so they are not used until reconnected */
153 spin_lock(&cifs_tcp_ses_lock);
154 list_for_each(tmp, &server->smb_ses_list) {
155 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
156 ses->need_reconnect = true;
158 list_for_each(tmp2, &ses->tcon_list) {
159 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
160 tcon->need_reconnect = true;
163 spin_unlock(&cifs_tcp_ses_lock);
164 /* do not want to be sending data on a socket we are freeing */
165 mutex_lock(&server->srv_mutex);
166 if (server->ssocket) {
167 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
168 server->ssocket->flags);
169 kernel_sock_shutdown(server->ssocket, SHUT_WR);
170 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
171 server->ssocket->state,
172 server->ssocket->flags);
173 sock_release(server->ssocket);
174 server->ssocket = NULL;
176 server->sequence_number = 0;
177 server->session_estab = false;
179 spin_lock(&GlobalMid_Lock);
180 list_for_each(tmp, &server->pending_mid_q) {
181 mid_entry = list_entry(tmp, struct
184 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
185 /* Mark other intransit requests as needing
186 retry so we do not immediately mark the
187 session bad again (ie after we reconnect
188 below) as they timeout too */
189 mid_entry->midState = MID_RETRY_NEEDED;
192 spin_unlock(&GlobalMid_Lock);
193 mutex_unlock(&server->srv_mutex);
195 while ((server->tcpStatus != CifsExiting) &&
196 (server->tcpStatus != CifsGood)) {
198 if (server->addr.sockAddr6.sin6_family == AF_INET6)
199 rc = ipv6_connect(server);
201 rc = ipv4_connect(server);
203 cFYI(1, "reconnect error %d", rc);
206 atomic_inc(&tcpSesReconnectCount);
207 spin_lock(&GlobalMid_Lock);
208 if (server->tcpStatus != CifsExiting)
209 server->tcpStatus = CifsGood;
210 spin_unlock(&GlobalMid_Lock);
211 /* atomic_set(&server->inFlight,0);*/
212 wake_up(&server->response_q);
220 0 not a transact2, or all data present
221 >0 transact2 with that much data missing
222 -EINVAL = invalid transact2
225 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
227 struct smb_t2_rsp *pSMBt;
229 int data_in_this_rsp;
232 if (pSMB->Command != SMB_COM_TRANSACTION2)
235 /* check for plausible wct, bcc and t2 data and parm sizes */
236 /* check for parm and data offset going beyond end of smb */
237 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
238 cFYI(1, "invalid transact2 word count");
242 pSMBt = (struct smb_t2_rsp *)pSMB;
244 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
245 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
247 remaining = total_data_size - data_in_this_rsp;
251 else if (remaining < 0) {
252 cFYI(1, "total data %d smaller than data in frame %d",
253 total_data_size, data_in_this_rsp);
256 cFYI(1, "missing %d bytes from transact2, check next response",
258 if (total_data_size > maxBufSize) {
259 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
260 total_data_size, maxBufSize);
267 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
269 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
270 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
275 char *data_area_of_target;
276 char *data_area_of_buf2;
279 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
281 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
282 cFYI(1, "total data size of primary and secondary t2 differ");
285 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
287 remaining = total_data_size - total_in_buf;
292 if (remaining == 0) /* nothing to do, ignore */
295 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
296 if (remaining < total_in_buf2) {
297 cFYI(1, "transact2 2nd response contains too much data");
300 /* find end of first SMB data area */
301 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
302 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
303 /* validate target area */
305 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
306 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
308 data_area_of_target += total_in_buf;
310 /* copy second buffer into end of first buffer */
311 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
312 total_in_buf += total_in_buf2;
313 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
314 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
315 byte_count += total_in_buf2;
316 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
318 byte_count = pTargetSMB->smb_buf_length;
319 byte_count += total_in_buf2;
321 /* BB also add check that we are not beyond maximum buffer size */
323 pTargetSMB->smb_buf_length = byte_count;
325 if (remaining == total_in_buf2) {
326 cFYI(1, "found the last secondary response");
327 return 0; /* we are done */
328 } else /* more responses to go */
334 cifs_demultiplex_thread(struct TCP_Server_Info *server)
337 unsigned int pdu_length, total_read;
338 struct smb_hdr *smb_buffer = NULL;
339 struct smb_hdr *bigbuf = NULL;
340 struct smb_hdr *smallbuf = NULL;
341 struct msghdr smb_msg;
343 struct socket *csocket = server->ssocket;
344 struct list_head *tmp;
345 struct cifsSesInfo *ses;
346 struct task_struct *task_to_wake = NULL;
347 struct mid_q_entry *mid_entry;
349 bool isLargeBuf = false;
353 current->flags |= PF_MEMALLOC;
354 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
356 length = atomic_inc_return(&tcpSesAllocCount);
358 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
362 while (server->tcpStatus != CifsExiting) {
365 if (bigbuf == NULL) {
366 bigbuf = cifs_buf_get();
368 cERROR(1, "No memory for large SMB response");
370 /* retry will check if exiting */
373 } else if (isLargeBuf) {
374 /* we are reusing a dirty large buf, clear its start */
375 memset(bigbuf, 0, sizeof(struct smb_hdr));
378 if (smallbuf == NULL) {
379 smallbuf = cifs_small_buf_get();
381 cERROR(1, "No memory for SMB response");
383 /* retry will check if exiting */
386 /* beginning of smb buffer is cleared in our buf_get */
387 } else /* if existing small buf clear beginning */
388 memset(smallbuf, 0, sizeof(struct smb_hdr));
392 smb_buffer = smallbuf;
393 iov.iov_base = smb_buffer;
395 smb_msg.msg_control = NULL;
396 smb_msg.msg_controllen = 0;
397 pdu_length = 4; /* enough to get RFC1001 header */
400 kernel_recvmsg(csocket, &smb_msg,
401 &iov, 1, pdu_length, 0 /* BB other flags? */);
403 if (server->tcpStatus == CifsExiting) {
405 } else if (server->tcpStatus == CifsNeedReconnect) {
406 cFYI(1, "Reconnect after server stopped responding");
407 cifs_reconnect(server);
408 cFYI(1, "call to reconnect done");
409 csocket = server->ssocket;
411 } else if (length == -ERESTARTSYS ||
414 msleep(1); /* minimum sleep to prevent looping
415 allowing socket to clear and app threads to set
416 tcpStatus CifsNeedReconnect if server hung */
417 if (pdu_length < 4) {
418 iov.iov_base = (4 - pdu_length) +
420 iov.iov_len = pdu_length;
421 smb_msg.msg_control = NULL;
422 smb_msg.msg_controllen = 0;
426 } else if (length <= 0) {
427 cFYI(1, "Reconnect after unexpected peek error %d",
429 cifs_reconnect(server);
430 csocket = server->ssocket;
431 wake_up(&server->response_q);
433 } else if (length < pdu_length) {
434 cFYI(1, "requested %d bytes but only got %d bytes",
436 pdu_length -= length;
441 /* The right amount was read from socket - 4 bytes */
442 /* so we can now interpret the length field */
444 /* the first byte big endian of the length field,
445 is actually not part of the length but the type
446 with the most common, zero, as regular data */
447 temp = *((char *) smb_buffer);
449 /* Note that FC 1001 length is big endian on the wire,
450 but we convert it here so it is always manipulated
451 as host byte order */
452 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
453 smb_buffer->smb_buf_length = pdu_length;
455 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
457 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
459 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
460 cFYI(1, "Good RFC 1002 session rsp");
462 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
463 /* we get this from Windows 98 instead of
464 an error on SMB negprot response */
465 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
467 /* give server a second to clean up */
469 /* always try 445 first on reconnect since we get NACK
470 * on some if we ever connected to port 139 (the NACK
471 * is since we do not begin with RFC1001 session
474 cifs_set_port((struct sockaddr *)
475 &server->addr.sockAddr, CIFS_PORT);
476 cifs_reconnect(server);
477 csocket = server->ssocket;
478 wake_up(&server->response_q);
480 } else if (temp != (char) 0) {
481 cERROR(1, "Unknown RFC 1002 frame");
482 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
484 cifs_reconnect(server);
485 csocket = server->ssocket;
489 /* else we have an SMB response */
490 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
491 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
492 cERROR(1, "Invalid size SMB length %d pdu_length %d",
493 length, pdu_length+4);
494 cifs_reconnect(server);
495 csocket = server->ssocket;
496 wake_up(&server->response_q);
503 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
505 memcpy(bigbuf, smallbuf, 4);
509 iov.iov_base = 4 + (char *)smb_buffer;
510 iov.iov_len = pdu_length;
511 for (total_read = 0; total_read < pdu_length;
512 total_read += length) {
513 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
514 pdu_length - total_read, 0);
515 if (server->tcpStatus == CifsExiting) {
519 } else if (server->tcpStatus == CifsNeedReconnect) {
520 cifs_reconnect(server);
521 csocket = server->ssocket;
522 /* Reconnect wakes up rspns q */
523 /* Now we will reread sock */
526 } else if (length == -ERESTARTSYS ||
529 msleep(1); /* minimum sleep to prevent looping,
530 allowing socket to clear and app
531 threads to set tcpStatus
532 CifsNeedReconnect if server hung*/
535 } else if (length <= 0) {
536 cERROR(1, "Received no data, expecting %d",
537 pdu_length - total_read);
538 cifs_reconnect(server);
539 csocket = server->ssocket;
546 else if (reconnect == 1)
549 length += 4; /* account for rfc1002 hdr */
552 dump_smb(smb_buffer, length);
553 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
554 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
560 spin_lock(&GlobalMid_Lock);
561 list_for_each(tmp, &server->pending_mid_q) {
562 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
564 if ((mid_entry->mid == smb_buffer->Mid) &&
565 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
566 (mid_entry->command == smb_buffer->Command)) {
567 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
568 /* We have a multipart transact2 resp */
570 if (mid_entry->resp_buf) {
571 /* merge response - fix up 1st*/
572 if (coalesce_t2(smb_buffer,
573 mid_entry->resp_buf)) {
574 mid_entry->multiRsp =
578 /* all parts received */
579 mid_entry->multiEnd =
585 cERROR(1, "1st trans2 resp needs bigbuf");
586 /* BB maybe we can fix this up, switch
587 to already allocated large buffer? */
589 /* Have first buffer */
590 mid_entry->resp_buf =
592 mid_entry->largeBuf =
599 mid_entry->resp_buf = smb_buffer;
600 mid_entry->largeBuf = isLargeBuf;
602 task_to_wake = mid_entry->tsk;
603 mid_entry->midState = MID_RESPONSE_RECEIVED;
604 #ifdef CONFIG_CIFS_STATS2
605 mid_entry->when_received = jiffies;
607 /* so we do not time out requests to server
608 which is still responding (since server could
609 be busy but not dead) */
610 server->lstrp = jiffies;
614 spin_unlock(&GlobalMid_Lock);
616 /* Was previous buf put in mpx struct for multi-rsp? */
618 /* smb buffer will be freed by user thread */
624 wake_up_process(task_to_wake);
625 } else if (!is_valid_oplock_break(smb_buffer, server) &&
627 cERROR(1, "No task to wake, unknown frame received! "
628 "NumMids %d", midCount.counter);
629 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
630 sizeof(struct smb_hdr));
631 #ifdef CONFIG_CIFS_DEBUG2
632 cifs_dump_detail(smb_buffer);
633 cifs_dump_mids(server);
634 #endif /* CIFS_DEBUG2 */
637 } /* end while !EXITING */
639 /* take it off the list, if it's not already */
640 spin_lock(&cifs_tcp_ses_lock);
641 list_del_init(&server->tcp_ses_list);
642 spin_unlock(&cifs_tcp_ses_lock);
644 spin_lock(&GlobalMid_Lock);
645 server->tcpStatus = CifsExiting;
646 spin_unlock(&GlobalMid_Lock);
647 wake_up_all(&server->response_q);
649 /* check if we have blocked requests that need to free */
650 /* Note that cifs_max_pending is normally 50, but
651 can be set at module install time to as little as two */
652 spin_lock(&GlobalMid_Lock);
653 if (atomic_read(&server->inFlight) >= cifs_max_pending)
654 atomic_set(&server->inFlight, cifs_max_pending - 1);
655 /* We do not want to set the max_pending too low or we
656 could end up with the counter going negative */
657 spin_unlock(&GlobalMid_Lock);
658 /* Although there should not be any requests blocked on
659 this queue it can not hurt to be paranoid and try to wake up requests
660 that may haven been blocked when more than 50 at time were on the wire
661 to the same server - they now will see the session is in exit state
662 and get out of SendReceive. */
663 wake_up_all(&server->request_q);
664 /* give those requests time to exit */
667 if (server->ssocket) {
668 sock_release(csocket);
669 server->ssocket = NULL;
671 /* buffer usuallly freed in free_mid - need to free it here on exit */
672 cifs_buf_release(bigbuf);
673 if (smallbuf) /* no sense logging a debug message if NULL */
674 cifs_small_buf_release(smallbuf);
677 * BB: we shouldn't have to do any of this. It shouldn't be
678 * possible to exit from the thread with active SMB sessions
680 spin_lock(&cifs_tcp_ses_lock);
681 if (list_empty(&server->pending_mid_q)) {
682 /* loop through server session structures attached to this and
684 list_for_each(tmp, &server->smb_ses_list) {
685 ses = list_entry(tmp, struct cifsSesInfo,
687 ses->status = CifsExiting;
690 spin_unlock(&cifs_tcp_ses_lock);
692 /* although we can not zero the server struct pointer yet,
693 since there are active requests which may depnd on them,
694 mark the corresponding SMB sessions as exiting too */
695 list_for_each(tmp, &server->smb_ses_list) {
696 ses = list_entry(tmp, struct cifsSesInfo,
698 ses->status = CifsExiting;
701 spin_lock(&GlobalMid_Lock);
702 list_for_each(tmp, &server->pending_mid_q) {
703 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
704 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
705 cFYI(1, "Clearing Mid 0x%x - waking up ",
707 task_to_wake = mid_entry->tsk;
709 wake_up_process(task_to_wake);
712 spin_unlock(&GlobalMid_Lock);
713 spin_unlock(&cifs_tcp_ses_lock);
714 /* 1/8th of sec is more than enough time for them to exit */
718 if (!list_empty(&server->pending_mid_q)) {
719 /* mpx threads have not exited yet give them
720 at least the smb send timeout time for long ops */
721 /* due to delays on oplock break requests, we need
722 to wait at least 45 seconds before giving up
723 on a request getting a response and going ahead
725 cFYI(1, "Wait for exit from demultiplex thread");
727 /* if threads still have not exited they are probably never
728 coming home not much else we can do but free the memory */
731 /* last chance to mark ses pointers invalid
732 if there are any pointing to this (e.g
733 if a crazy root user tried to kill cifsd
734 kernel thread explicitly this might happen) */
735 /* BB: This shouldn't be necessary, see above */
736 spin_lock(&cifs_tcp_ses_lock);
737 list_for_each(tmp, &server->smb_ses_list) {
738 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
741 spin_unlock(&cifs_tcp_ses_lock);
743 kfree(server->hostname);
744 task_to_wake = xchg(&server->tsk, NULL);
747 length = atomic_dec_return(&tcpSesAllocCount);
749 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
752 /* if server->tsk was NULL then wait for a signal before exiting */
754 set_current_state(TASK_INTERRUPTIBLE);
755 while (!signal_pending(current)) {
757 set_current_state(TASK_INTERRUPTIBLE);
759 set_current_state(TASK_RUNNING);
762 module_put_and_exit(0);
765 /* extract the host portion of the UNC string */
767 extract_hostname(const char *unc)
773 /* skip double chars at beginning of string */
774 /* BB: check validity of these bytes? */
777 /* delimiter between hostname and sharename is always '\\' now */
778 delim = strchr(src, '\\');
780 return ERR_PTR(-EINVAL);
783 dst = kmalloc((len + 1), GFP_KERNEL);
785 return ERR_PTR(-ENOMEM);
787 memcpy(dst, src, len);
794 cifs_parse_mount_options(char *options, const char *devname,
799 unsigned int temp_len, i, j;
801 short int override_uid = -1;
802 short int override_gid = -1;
803 bool uid_specified = false;
804 bool gid_specified = false;
809 if (Local_System_Name[0] != 0)
810 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
812 char *nodename = utsname()->nodename;
813 int n = strnlen(nodename, 15);
814 memset(vol->source_rfc1001_name, 0x20, 15);
815 for (i = 0; i < n; i++) {
816 /* does not have to be perfect mapping since field is
817 informational, only used for servers that do not support
818 port 445 and it can be overridden at mount time */
819 vol->source_rfc1001_name[i] = toupper(nodename[i]);
822 vol->source_rfc1001_name[15] = 0;
823 /* null target name indicates to use *SMBSERVR default called name
824 if we end up sending RFC1001 session initialize */
825 vol->target_rfc1001_name[0] = 0;
826 vol->cred_uid = current_uid();
827 vol->linux_uid = current_uid();
828 vol->linux_gid = current_gid();
830 /* default to only allowing write access to owner of the mount */
831 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
833 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
834 /* default is always to request posix paths. */
835 vol->posix_paths = 1;
836 /* default to using server inode numbers where available */
842 if (strncmp(options, "sep=", 4) == 0) {
843 if (options[4] != 0) {
844 separator[0] = options[4];
847 cFYI(1, "Null separator not allowed");
851 while ((data = strsep(&options, separator)) != NULL) {
854 if ((value = strchr(data, '=')) != NULL)
857 /* Have to parse this before we parse for "user" */
858 if (strnicmp(data, "user_xattr", 10) == 0) {
860 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
862 } else if (strnicmp(data, "user", 4) == 0) {
865 "CIFS: invalid or missing username\n");
866 return 1; /* needs_arg; */
867 } else if (!*value) {
868 /* null user, ie anonymous, authentication */
871 if (strnlen(value, 200) < 200) {
872 vol->username = value;
874 printk(KERN_WARNING "CIFS: username too long\n");
877 } else if (strnicmp(data, "pass", 4) == 0) {
879 vol->password = NULL;
881 } else if (value[0] == 0) {
882 /* check if string begins with double comma
883 since that would mean the password really
884 does start with a comma, and would not
885 indicate an empty string */
886 if (value[1] != separator[0]) {
887 vol->password = NULL;
891 temp_len = strlen(value);
892 /* removed password length check, NTLM passwords
893 can be arbitrarily long */
895 /* if comma in password, the string will be
896 prematurely null terminated. Commas in password are
897 specified across the cifs mount interface by a double
898 comma ie ,, and a comma used as in other cases ie ','
899 as a parameter delimiter/separator is single and due
900 to the strsep above is temporarily zeroed. */
902 /* NB: password legally can have multiple commas and
903 the only illegal character in a password is null */
905 if ((value[temp_len] == 0) &&
906 (value[temp_len+1] == separator[0])) {
908 value[temp_len] = separator[0];
909 temp_len += 2; /* move after second comma */
910 while (value[temp_len] != 0) {
911 if (value[temp_len] == separator[0]) {
912 if (value[temp_len+1] ==
914 /* skip second comma */
917 /* single comma indicating start
924 if (value[temp_len] == 0) {
928 /* point option to start of next parm */
929 options = value + temp_len + 1;
931 /* go from value to value + temp_len condensing
932 double commas to singles. Note that this ends up
933 allocating a few bytes too many, which is ok */
934 vol->password = kzalloc(temp_len, GFP_KERNEL);
935 if (vol->password == NULL) {
936 printk(KERN_WARNING "CIFS: no memory "
940 for (i = 0, j = 0; i < temp_len; i++, j++) {
941 vol->password[j] = value[i];
942 if (value[i] == separator[0]
943 && value[i+1] == separator[0]) {
944 /* skip second comma */
948 vol->password[j] = 0;
950 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
951 if (vol->password == NULL) {
952 printk(KERN_WARNING "CIFS: no memory "
956 strcpy(vol->password, value);
958 } else if (!strnicmp(data, "ip", 2) ||
959 !strnicmp(data, "addr", 4)) {
960 if (!value || !*value) {
962 } else if (strnlen(value, INET6_ADDRSTRLEN) <
966 printk(KERN_WARNING "CIFS: ip address "
970 } else if (strnicmp(data, "sec", 3) == 0) {
971 if (!value || !*value) {
972 cERROR(1, "no security value specified");
974 } else if (strnicmp(value, "krb5i", 5) == 0) {
975 vol->secFlg |= CIFSSEC_MAY_KRB5 |
977 } else if (strnicmp(value, "krb5p", 5) == 0) {
978 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
980 cERROR(1, "Krb5 cifs privacy not supported");
982 } else if (strnicmp(value, "krb5", 4) == 0) {
983 vol->secFlg |= CIFSSEC_MAY_KRB5;
984 #ifdef CONFIG_CIFS_EXPERIMENTAL
985 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
986 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
988 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
989 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
991 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
992 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
994 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
995 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
996 } else if (strnicmp(value, "ntlmi", 5) == 0) {
997 vol->secFlg |= CIFSSEC_MAY_NTLM |
999 } else if (strnicmp(value, "ntlm", 4) == 0) {
1000 /* ntlm is default so can be turned off too */
1001 vol->secFlg |= CIFSSEC_MAY_NTLM;
1002 } else if (strnicmp(value, "nontlm", 6) == 0) {
1003 /* BB is there a better way to do this? */
1004 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1005 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1006 } else if (strnicmp(value, "lanman", 6) == 0) {
1007 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1009 } else if (strnicmp(value, "none", 4) == 0) {
1012 cERROR(1, "bad security option: %s", value);
1015 } else if ((strnicmp(data, "unc", 3) == 0)
1016 || (strnicmp(data, "target", 6) == 0)
1017 || (strnicmp(data, "path", 4) == 0)) {
1018 if (!value || !*value) {
1019 printk(KERN_WARNING "CIFS: invalid path to "
1020 "network resource\n");
1021 return 1; /* needs_arg; */
1023 if ((temp_len = strnlen(value, 300)) < 300) {
1024 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1025 if (vol->UNC == NULL)
1027 strcpy(vol->UNC, value);
1028 if (strncmp(vol->UNC, "//", 2) == 0) {
1031 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1033 "CIFS: UNC Path does not begin "
1034 "with // or \\\\ \n");
1038 printk(KERN_WARNING "CIFS: UNC name too long\n");
1041 } else if ((strnicmp(data, "domain", 3) == 0)
1042 || (strnicmp(data, "workgroup", 5) == 0)) {
1043 if (!value || !*value) {
1044 printk(KERN_WARNING "CIFS: invalid domain name\n");
1045 return 1; /* needs_arg; */
1047 /* BB are there cases in which a comma can be valid in
1048 a domain name and need special handling? */
1049 if (strnlen(value, 256) < 256) {
1050 vol->domainname = value;
1051 cFYI(1, "Domain name set");
1053 printk(KERN_WARNING "CIFS: domain name too "
1057 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1058 vol->srcaddr.ss_family = AF_UNSPEC;
1060 if (!value || !*value) {
1061 printk(KERN_WARNING "CIFS: srcaddr value"
1062 " not specified.\n");
1063 return 1; /* needs_arg; */
1065 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1066 value, strlen(value));
1068 printk(KERN_WARNING "CIFS: Could not parse"
1073 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1074 if (!value || !*value) {
1076 "CIFS: invalid path prefix\n");
1077 return 1; /* needs_argument */
1079 if ((temp_len = strnlen(value, 1024)) < 1024) {
1080 if (value[0] != '/')
1081 temp_len++; /* missing leading slash */
1082 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1083 if (vol->prepath == NULL)
1085 if (value[0] != '/') {
1086 vol->prepath[0] = '/';
1087 strcpy(vol->prepath+1, value);
1089 strcpy(vol->prepath, value);
1090 cFYI(1, "prefix path %s", vol->prepath);
1092 printk(KERN_WARNING "CIFS: prefix too long\n");
1095 } else if (strnicmp(data, "iocharset", 9) == 0) {
1096 if (!value || !*value) {
1097 printk(KERN_WARNING "CIFS: invalid iocharset "
1099 return 1; /* needs_arg; */
1101 if (strnlen(value, 65) < 65) {
1102 if (strnicmp(value, "default", 7))
1103 vol->iocharset = value;
1104 /* if iocharset not set then load_nls_default
1105 is used by caller */
1106 cFYI(1, "iocharset set to %s", value);
1108 printk(KERN_WARNING "CIFS: iocharset name "
1112 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1113 vol->linux_uid = simple_strtoul(value, &value, 0);
1114 uid_specified = true;
1115 } else if (!strnicmp(data, "forceuid", 8)) {
1117 } else if (!strnicmp(data, "noforceuid", 10)) {
1119 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1120 vol->linux_gid = simple_strtoul(value, &value, 0);
1121 gid_specified = true;
1122 } else if (!strnicmp(data, "forcegid", 8)) {
1124 } else if (!strnicmp(data, "noforcegid", 10)) {
1126 } else if (strnicmp(data, "file_mode", 4) == 0) {
1127 if (value && *value) {
1129 simple_strtoul(value, &value, 0);
1131 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1132 if (value && *value) {
1134 simple_strtoul(value, &value, 0);
1136 } else if (strnicmp(data, "dirmode", 4) == 0) {
1137 if (value && *value) {
1139 simple_strtoul(value, &value, 0);
1141 } else if (strnicmp(data, "port", 4) == 0) {
1142 if (value && *value) {
1144 simple_strtoul(value, &value, 0);
1146 } else if (strnicmp(data, "rsize", 5) == 0) {
1147 if (value && *value) {
1149 simple_strtoul(value, &value, 0);
1151 } else if (strnicmp(data, "wsize", 5) == 0) {
1152 if (value && *value) {
1154 simple_strtoul(value, &value, 0);
1156 } else if (strnicmp(data, "sockopt", 5) == 0) {
1157 if (!value || !*value) {
1158 cERROR(1, "no socket option specified");
1160 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1161 vol->sockopt_tcp_nodelay = 1;
1163 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1164 if (!value || !*value || (*value == ' ')) {
1165 cFYI(1, "invalid (empty) netbiosname");
1167 memset(vol->source_rfc1001_name, 0x20, 15);
1168 for (i = 0; i < 15; i++) {
1169 /* BB are there cases in which a comma can be
1170 valid in this workstation netbios name (and need
1171 special handling)? */
1173 /* We do not uppercase netbiosname for user */
1177 vol->source_rfc1001_name[i] =
1180 /* The string has 16th byte zero still from
1181 set at top of the function */
1182 if ((i == 15) && (value[i] != 0))
1183 printk(KERN_WARNING "CIFS: netbiosname"
1184 " longer than 15 truncated.\n");
1186 } else if (strnicmp(data, "servern", 7) == 0) {
1187 /* servernetbiosname specified override *SMBSERVER */
1188 if (!value || !*value || (*value == ' ')) {
1189 cFYI(1, "empty server netbiosname specified");
1191 /* last byte, type, is 0x20 for servr type */
1192 memset(vol->target_rfc1001_name, 0x20, 16);
1194 for (i = 0; i < 15; i++) {
1195 /* BB are there cases in which a comma can be
1196 valid in this workstation netbios name
1197 (and need special handling)? */
1199 /* user or mount helper must uppercase
1204 vol->target_rfc1001_name[i] =
1207 /* The string has 16th byte zero still from
1208 set at top of the function */
1209 if ((i == 15) && (value[i] != 0))
1210 printk(KERN_WARNING "CIFS: server net"
1211 "biosname longer than 15 truncated.\n");
1213 } else if (strnicmp(data, "credentials", 4) == 0) {
1215 } else if (strnicmp(data, "version", 3) == 0) {
1217 } else if (strnicmp(data, "guest", 5) == 0) {
1219 } else if (strnicmp(data, "rw", 2) == 0) {
1221 } else if (strnicmp(data, "ro", 2) == 0) {
1223 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1224 vol->noblocksnd = 1;
1225 } else if (strnicmp(data, "noautotune", 10) == 0) {
1226 vol->noautotune = 1;
1227 } else if ((strnicmp(data, "suid", 4) == 0) ||
1228 (strnicmp(data, "nosuid", 6) == 0) ||
1229 (strnicmp(data, "exec", 4) == 0) ||
1230 (strnicmp(data, "noexec", 6) == 0) ||
1231 (strnicmp(data, "nodev", 5) == 0) ||
1232 (strnicmp(data, "noauto", 6) == 0) ||
1233 (strnicmp(data, "dev", 3) == 0)) {
1234 /* The mount tool or mount.cifs helper (if present)
1235 uses these opts to set flags, and the flags are read
1236 by the kernel vfs layer before we get here (ie
1237 before read super) so there is no point trying to
1238 parse these options again and set anything and it
1239 is ok to just ignore them */
1241 } else if (strnicmp(data, "hard", 4) == 0) {
1243 } else if (strnicmp(data, "soft", 4) == 0) {
1245 } else if (strnicmp(data, "perm", 4) == 0) {
1247 } else if (strnicmp(data, "noperm", 6) == 0) {
1249 } else if (strnicmp(data, "mapchars", 8) == 0) {
1251 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1253 } else if (strnicmp(data, "sfu", 3) == 0) {
1255 } else if (strnicmp(data, "nosfu", 5) == 0) {
1257 } else if (strnicmp(data, "nodfs", 5) == 0) {
1259 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1260 vol->posix_paths = 1;
1261 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1262 vol->posix_paths = 0;
1263 } else if (strnicmp(data, "nounix", 6) == 0) {
1264 vol->no_linux_ext = 1;
1265 } else if (strnicmp(data, "nolinux", 7) == 0) {
1266 vol->no_linux_ext = 1;
1267 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1268 (strnicmp(data, "ignorecase", 10) == 0)) {
1270 } else if (strnicmp(data, "mand", 4) == 0) {
1272 } else if (strnicmp(data, "nomand", 6) == 0) {
1274 } else if (strnicmp(data, "_netdev", 7) == 0) {
1276 } else if (strnicmp(data, "brl", 3) == 0) {
1278 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1279 (strnicmp(data, "nolock", 6) == 0)) {
1281 /* turn off mandatory locking in mode
1282 if remote locking is turned off since the
1283 local vfs will do advisory */
1284 if (vol->file_mode ==
1285 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1286 vol->file_mode = S_IALLUGO;
1287 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1288 /* will take the shorter form "forcemand" as well */
1289 /* This mount option will force use of mandatory
1290 (DOS/Windows style) byte range locks, instead of
1291 using posix advisory byte range locks, even if the
1292 Unix extensions are available and posix locks would
1293 be supported otherwise. If Unix extensions are not
1294 negotiated this has no effect since mandatory locks
1295 would be used (mandatory locks is all that those
1296 those servers support) */
1298 } else if (strnicmp(data, "setuids", 7) == 0) {
1300 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1302 } else if (strnicmp(data, "dynperm", 7) == 0) {
1303 vol->dynperm = true;
1304 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1305 vol->dynperm = false;
1306 } else if (strnicmp(data, "nohard", 6) == 0) {
1308 } else if (strnicmp(data, "nosoft", 6) == 0) {
1310 } else if (strnicmp(data, "nointr", 6) == 0) {
1312 } else if (strnicmp(data, "intr", 4) == 0) {
1314 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1315 vol->nostrictsync = 1;
1316 } else if (strnicmp(data, "strictsync", 10) == 0) {
1317 vol->nostrictsync = 0;
1318 } else if (strnicmp(data, "serverino", 7) == 0) {
1319 vol->server_ino = 1;
1320 } else if (strnicmp(data, "noserverino", 9) == 0) {
1321 vol->server_ino = 0;
1322 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1324 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1326 } else if (strnicmp(data, "acl", 3) == 0) {
1327 vol->no_psx_acl = 0;
1328 } else if (strnicmp(data, "noacl", 5) == 0) {
1329 vol->no_psx_acl = 1;
1330 #ifdef CONFIG_CIFS_EXPERIMENTAL
1331 } else if (strnicmp(data, "locallease", 6) == 0) {
1332 vol->local_lease = 1;
1334 } else if (strnicmp(data, "sign", 4) == 0) {
1335 vol->secFlg |= CIFSSEC_MUST_SIGN;
1336 } else if (strnicmp(data, "seal", 4) == 0) {
1337 /* we do not do the following in secFlags because seal
1338 is a per tree connection (mount) not a per socket
1339 or per-smb connection option in the protocol */
1340 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1342 } else if (strnicmp(data, "direct", 6) == 0) {
1344 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1346 } else if (strnicmp(data, "noac", 4) == 0) {
1347 printk(KERN_WARNING "CIFS: Mount option noac not "
1348 "supported. Instead set "
1349 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1350 } else if (strnicmp(data, "fsc", 3) == 0) {
1352 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1353 vol->mfsymlinks = true;
1354 } else if (strnicmp(data, "multiuser", 8) == 0) {
1355 vol->multiuser = true;
1357 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1360 if (vol->UNC == NULL) {
1361 if (devname == NULL) {
1362 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1366 if ((temp_len = strnlen(devname, 300)) < 300) {
1367 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1368 if (vol->UNC == NULL)
1370 strcpy(vol->UNC, devname);
1371 if (strncmp(vol->UNC, "//", 2) == 0) {
1374 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1375 printk(KERN_WARNING "CIFS: UNC Path does not "
1376 "begin with // or \\\\ \n");
1379 value = strpbrk(vol->UNC+2, "/\\");
1383 printk(KERN_WARNING "CIFS: UNC name too long\n");
1388 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1389 cERROR(1, "Multiuser mounts currently require krb5 "
1394 if (vol->UNCip == NULL)
1395 vol->UNCip = &vol->UNC[2];
1398 vol->override_uid = override_uid;
1399 else if (override_uid == 1)
1400 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1401 "specified with no uid= option.\n");
1404 vol->override_gid = override_gid;
1405 else if (override_gid == 1)
1406 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1407 "specified with no gid= option.\n");
1412 /** Returns true if srcaddr isn't specified and rhs isn't
1413 * specified, or if srcaddr is specified and
1414 * matches the IP address of the rhs argument.
1417 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1419 switch (srcaddr->sa_family) {
1421 return (rhs->sa_family == AF_UNSPEC);
1423 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1424 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1425 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1428 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1429 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1430 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1434 return false; /* don't expect to be here */
1440 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1441 struct sockaddr *srcaddr)
1443 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1444 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1446 switch (addr->sa_family) {
1448 if (addr4->sin_addr.s_addr !=
1449 server->addr.sockAddr.sin_addr.s_addr)
1451 if (addr4->sin_port &&
1452 addr4->sin_port != server->addr.sockAddr.sin_port)
1456 if (!ipv6_addr_equal(&addr6->sin6_addr,
1457 &server->addr.sockAddr6.sin6_addr))
1459 if (addr6->sin6_scope_id !=
1460 server->addr.sockAddr6.sin6_scope_id)
1462 if (addr6->sin6_port &&
1463 addr6->sin6_port != server->addr.sockAddr6.sin6_port)
1468 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1475 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1477 unsigned int secFlags;
1479 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1480 secFlags = vol->secFlg;
1482 secFlags = global_secflags | vol->secFlg;
1484 switch (server->secType) {
1486 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1490 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1494 if (!(secFlags & CIFSSEC_MAY_NTLM))
1498 if (!(secFlags & CIFSSEC_MAY_KRB5))
1502 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1506 /* shouldn't happen */
1510 /* now check if signing mode is acceptible */
1511 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1512 (server->secMode & SECMODE_SIGN_REQUIRED))
1514 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1516 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1522 static struct TCP_Server_Info *
1523 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1525 struct TCP_Server_Info *server;
1527 spin_lock(&cifs_tcp_ses_lock);
1528 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1529 if (!match_address(server, addr,
1530 (struct sockaddr *)&vol->srcaddr))
1533 if (!match_security(server, vol))
1536 ++server->srv_count;
1537 spin_unlock(&cifs_tcp_ses_lock);
1538 cFYI(1, "Existing tcp session with server found");
1541 spin_unlock(&cifs_tcp_ses_lock);
1546 cifs_put_tcp_session(struct TCP_Server_Info *server)
1548 struct task_struct *task;
1550 spin_lock(&cifs_tcp_ses_lock);
1551 if (--server->srv_count > 0) {
1552 spin_unlock(&cifs_tcp_ses_lock);
1556 list_del_init(&server->tcp_ses_list);
1557 spin_unlock(&cifs_tcp_ses_lock);
1559 spin_lock(&GlobalMid_Lock);
1560 server->tcpStatus = CifsExiting;
1561 spin_unlock(&GlobalMid_Lock);
1563 cifs_fscache_release_client_cookie(server);
1565 task = xchg(&server->tsk, NULL);
1567 force_sig(SIGKILL, task);
1570 static struct TCP_Server_Info *
1571 cifs_get_tcp_session(struct smb_vol *volume_info)
1573 struct TCP_Server_Info *tcp_ses = NULL;
1574 struct sockaddr_storage addr;
1575 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1576 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1579 memset(&addr, 0, sizeof(struct sockaddr_storage));
1581 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1583 if (volume_info->UNCip && volume_info->UNC) {
1584 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1586 strlen(volume_info->UNCip),
1589 /* we failed translating address */
1593 } else if (volume_info->UNCip) {
1594 /* BB using ip addr as tcp_ses name to connect to the
1596 cERROR(1, "Connecting to DFS root not implemented yet");
1599 } else /* which tcp_sess DFS root would we conect to */ {
1600 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1601 "unc=//192.168.1.100/public) specified");
1606 /* see if we already have a matching tcp_ses */
1607 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1611 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1617 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1618 if (IS_ERR(tcp_ses->hostname)) {
1619 rc = PTR_ERR(tcp_ses->hostname);
1623 tcp_ses->noblocksnd = volume_info->noblocksnd;
1624 tcp_ses->noautotune = volume_info->noautotune;
1625 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1626 atomic_set(&tcp_ses->inFlight, 0);
1627 init_waitqueue_head(&tcp_ses->response_q);
1628 init_waitqueue_head(&tcp_ses->request_q);
1629 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1630 mutex_init(&tcp_ses->srv_mutex);
1631 memcpy(tcp_ses->workstation_RFC1001_name,
1632 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1633 memcpy(tcp_ses->server_RFC1001_name,
1634 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1635 tcp_ses->session_estab = false;
1636 tcp_ses->sequence_number = 0;
1637 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1638 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1641 * at this point we are the only ones with the pointer
1642 * to the struct since the kernel thread not created yet
1643 * no need to spinlock this init of tcpStatus or srv_count
1645 tcp_ses->tcpStatus = CifsNew;
1646 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1647 sizeof(tcp_ses->srcaddr));
1648 ++tcp_ses->srv_count;
1650 if (addr.ss_family == AF_INET6) {
1651 cFYI(1, "attempting ipv6 connect");
1652 /* BB should we allow ipv6 on port 139? */
1653 /* other OS never observed in Wild doing 139 with v6 */
1654 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1655 sizeof(struct sockaddr_in6));
1656 rc = ipv6_connect(tcp_ses);
1658 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1659 sizeof(struct sockaddr_in));
1660 rc = ipv4_connect(tcp_ses);
1663 cERROR(1, "Error connecting to socket. Aborting operation");
1668 * since we're in a cifs function already, we know that
1669 * this will succeed. No need for try_module_get().
1671 __module_get(THIS_MODULE);
1672 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1674 if (IS_ERR(tcp_ses->tsk)) {
1675 rc = PTR_ERR(tcp_ses->tsk);
1676 cERROR(1, "error %d create cifsd thread", rc);
1677 module_put(THIS_MODULE);
1681 /* thread spawned, put it on the list */
1682 spin_lock(&cifs_tcp_ses_lock);
1683 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1684 spin_unlock(&cifs_tcp_ses_lock);
1686 cifs_fscache_get_client_cookie(tcp_ses);
1692 if (!IS_ERR(tcp_ses->hostname))
1693 kfree(tcp_ses->hostname);
1694 if (tcp_ses->ssocket)
1695 sock_release(tcp_ses->ssocket);
1701 static struct cifsSesInfo *
1702 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1704 struct cifsSesInfo *ses;
1706 spin_lock(&cifs_tcp_ses_lock);
1707 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1708 switch (server->secType) {
1710 if (vol->cred_uid != ses->cred_uid)
1714 /* anything else takes username/password */
1715 if (strncmp(ses->userName, vol->username,
1718 if (strlen(vol->username) != 0 &&
1719 ses->password != NULL &&
1720 strncmp(ses->password,
1721 vol->password ? vol->password : "",
1726 spin_unlock(&cifs_tcp_ses_lock);
1729 spin_unlock(&cifs_tcp_ses_lock);
1734 cifs_put_smb_ses(struct cifsSesInfo *ses)
1737 struct TCP_Server_Info *server = ses->server;
1739 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1740 spin_lock(&cifs_tcp_ses_lock);
1741 if (--ses->ses_count > 0) {
1742 spin_unlock(&cifs_tcp_ses_lock);
1746 list_del_init(&ses->smb_ses_list);
1747 spin_unlock(&cifs_tcp_ses_lock);
1749 if (ses->status == CifsGood) {
1751 CIFSSMBLogoff(xid, ses);
1755 cifs_put_tcp_session(server);
1758 static struct cifsSesInfo *
1759 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1761 int rc = -ENOMEM, xid;
1762 struct cifsSesInfo *ses;
1766 ses = cifs_find_smb_ses(server, volume_info);
1768 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1770 mutex_lock(&ses->session_mutex);
1771 rc = cifs_negotiate_protocol(xid, ses);
1773 mutex_unlock(&ses->session_mutex);
1774 /* problem -- put our ses reference */
1775 cifs_put_smb_ses(ses);
1779 if (ses->need_reconnect) {
1780 cFYI(1, "Session needs reconnect");
1781 rc = cifs_setup_session(xid, ses,
1782 volume_info->local_nls);
1784 mutex_unlock(&ses->session_mutex);
1785 /* problem -- put our reference */
1786 cifs_put_smb_ses(ses);
1791 mutex_unlock(&ses->session_mutex);
1793 /* existing SMB ses has a server reference already */
1794 cifs_put_tcp_session(server);
1799 cFYI(1, "Existing smb sess not found");
1800 ses = sesInfoAlloc();
1806 /* new SMB session uses our server ref */
1807 ses->server = server;
1808 if (server->addr.sockAddr6.sin6_family == AF_INET6)
1809 sprintf(ses->serverName, "%pI6",
1810 &server->addr.sockAddr6.sin6_addr);
1812 sprintf(ses->serverName, "%pI4",
1813 &server->addr.sockAddr.sin_addr.s_addr);
1815 if (volume_info->username)
1816 strncpy(ses->userName, volume_info->username,
1819 /* volume_info->password freed at unmount */
1820 if (volume_info->password) {
1821 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1825 if (volume_info->domainname) {
1826 int len = strlen(volume_info->domainname);
1827 ses->domainName = kmalloc(len + 1, GFP_KERNEL);
1828 if (ses->domainName)
1829 strcpy(ses->domainName, volume_info->domainname);
1831 ses->cred_uid = volume_info->cred_uid;
1832 ses->linux_uid = volume_info->linux_uid;
1833 ses->overrideSecFlg = volume_info->secFlg;
1835 mutex_lock(&ses->session_mutex);
1836 rc = cifs_negotiate_protocol(xid, ses);
1838 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1839 mutex_unlock(&ses->session_mutex);
1843 /* success, put it on the list */
1844 spin_lock(&cifs_tcp_ses_lock);
1845 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1846 spin_unlock(&cifs_tcp_ses_lock);
1857 static struct cifsTconInfo *
1858 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1860 struct list_head *tmp;
1861 struct cifsTconInfo *tcon;
1863 spin_lock(&cifs_tcp_ses_lock);
1864 list_for_each(tmp, &ses->tcon_list) {
1865 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1866 if (tcon->tidStatus == CifsExiting)
1868 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1872 spin_unlock(&cifs_tcp_ses_lock);
1875 spin_unlock(&cifs_tcp_ses_lock);
1880 cifs_put_tcon(struct cifsTconInfo *tcon)
1883 struct cifsSesInfo *ses = tcon->ses;
1885 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1886 spin_lock(&cifs_tcp_ses_lock);
1887 if (--tcon->tc_count > 0) {
1888 spin_unlock(&cifs_tcp_ses_lock);
1892 list_del_init(&tcon->tcon_list);
1893 spin_unlock(&cifs_tcp_ses_lock);
1896 CIFSSMBTDis(xid, tcon);
1899 cifs_fscache_release_super_cookie(tcon);
1901 cifs_put_smb_ses(ses);
1904 static struct cifsTconInfo *
1905 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1908 struct cifsTconInfo *tcon;
1910 tcon = cifs_find_tcon(ses, volume_info->UNC);
1912 cFYI(1, "Found match on UNC path");
1913 /* existing tcon already has a reference */
1914 cifs_put_smb_ses(ses);
1915 if (tcon->seal != volume_info->seal)
1916 cERROR(1, "transport encryption setting "
1917 "conflicts with existing tid");
1921 tcon = tconInfoAlloc();
1928 if (volume_info->password) {
1929 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
1930 if (!tcon->password) {
1936 if (strchr(volume_info->UNC + 3, '\\') == NULL
1937 && strchr(volume_info->UNC + 3, '/') == NULL) {
1938 cERROR(1, "Missing share name");
1943 /* BB Do we need to wrap session_mutex around
1944 * this TCon call and Unix SetFS as
1945 * we do on SessSetup and reconnect? */
1947 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
1949 cFYI(1, "CIFS Tcon rc = %d", rc);
1953 if (volume_info->nodfs) {
1954 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
1955 cFYI(1, "DFS disabled (%d)", tcon->Flags);
1957 tcon->seal = volume_info->seal;
1958 /* we can have only one retry value for a connection
1959 to a share so for resources mounted more than once
1960 to the same server share the last value passed in
1961 for the retry flag is used */
1962 tcon->retry = volume_info->retry;
1963 tcon->nocase = volume_info->nocase;
1964 tcon->local_lease = volume_info->local_lease;
1966 spin_lock(&cifs_tcp_ses_lock);
1967 list_add(&tcon->tcon_list, &ses->tcon_list);
1968 spin_unlock(&cifs_tcp_ses_lock);
1970 cifs_fscache_get_super_cookie(tcon);
1980 cifs_put_tlink(struct tcon_link *tlink)
1982 if (!tlink || IS_ERR(tlink))
1985 if (!atomic_dec_and_test(&tlink->tl_count) ||
1986 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
1987 tlink->tl_time = jiffies;
1991 if (!IS_ERR(tlink_tcon(tlink)))
1992 cifs_put_tcon(tlink_tcon(tlink));
1998 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1999 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2000 struct dfs_info3_param **preferrals, int remap)
2005 *pnum_referrals = 0;
2008 if (pSesInfo->ipc_tid == 0) {
2009 temp_unc = kmalloc(2 /* for slashes */ +
2010 strnlen(pSesInfo->serverName,
2011 SERVER_NAME_LEN_WITH_NULL * 2)
2012 + 1 + 4 /* slash IPC$ */ + 2,
2014 if (temp_unc == NULL)
2018 strcpy(temp_unc + 2, pSesInfo->serverName);
2019 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2020 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2021 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2025 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2026 pnum_referrals, nls_codepage, remap);
2027 /* BB map targetUNCs to dfs_info3 structures, here or
2028 in CIFSGetDFSRefer BB */
2033 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2034 static struct lock_class_key cifs_key[2];
2035 static struct lock_class_key cifs_slock_key[2];
2038 cifs_reclassify_socket4(struct socket *sock)
2040 struct sock *sk = sock->sk;
2041 BUG_ON(sock_owned_by_user(sk));
2042 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2043 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2047 cifs_reclassify_socket6(struct socket *sock)
2049 struct sock *sk = sock->sk;
2050 BUG_ON(sock_owned_by_user(sk));
2051 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2052 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2056 cifs_reclassify_socket4(struct socket *sock)
2061 cifs_reclassify_socket6(struct socket *sock)
2066 /* See RFC1001 section 14 on representation of Netbios names */
2067 static void rfc1002mangle(char *target, char *source, unsigned int length)
2071 for (i = 0, j = 0; i < (length); i++) {
2072 /* mask a nibble at a time and encode */
2073 target[j] = 'A' + (0x0F & (source[i] >> 4));
2074 target[j+1] = 'A' + (0x0F & source[i]);
2081 bind_socket(struct TCP_Server_Info *server)
2084 if (server->srcaddr.ss_family != AF_UNSPEC) {
2085 /* Bind to the specified local IP address */
2086 struct socket *socket = server->ssocket;
2087 rc = socket->ops->bind(socket,
2088 (struct sockaddr *) &server->srcaddr,
2089 sizeof(server->srcaddr));
2091 struct sockaddr_in *saddr4;
2092 struct sockaddr_in6 *saddr6;
2093 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2094 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2095 if (saddr6->sin6_family == AF_INET6)
2097 "Failed to bind to: %pI6c, error: %d\n",
2098 &saddr6->sin6_addr, rc);
2101 "Failed to bind to: %pI4, error: %d\n",
2102 &saddr4->sin_addr.s_addr, rc);
2109 ipv4_connect(struct TCP_Server_Info *server)
2113 bool connected = false;
2114 __be16 orig_port = 0;
2115 struct socket *socket = server->ssocket;
2117 if (socket == NULL) {
2118 rc = sock_create_kern(PF_INET, SOCK_STREAM,
2119 IPPROTO_TCP, &socket);
2121 cERROR(1, "Error %d creating socket", rc);
2125 /* BB other socket options to set KEEPALIVE, NODELAY? */
2126 cFYI(1, "Socket created");
2127 server->ssocket = socket;
2128 socket->sk->sk_allocation = GFP_NOFS;
2129 cifs_reclassify_socket4(socket);
2132 rc = bind_socket(server);
2136 /* user overrode default port */
2137 if (server->addr.sockAddr.sin_port) {
2138 rc = socket->ops->connect(socket, (struct sockaddr *)
2139 &server->addr.sockAddr,
2140 sizeof(struct sockaddr_in), 0);
2146 /* save original port so we can retry user specified port
2147 later if fall back ports fail this time */
2148 orig_port = server->addr.sockAddr.sin_port;
2150 /* do not retry on the same port we just failed on */
2151 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
2152 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
2153 rc = socket->ops->connect(socket,
2155 &server->addr.sockAddr,
2156 sizeof(struct sockaddr_in), 0);
2162 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
2163 rc = socket->ops->connect(socket, (struct sockaddr *)
2164 &server->addr.sockAddr,
2165 sizeof(struct sockaddr_in), 0);
2170 /* give up here - unless we want to retry on different
2171 protocol families some day */
2174 server->addr.sockAddr.sin_port = orig_port;
2175 cFYI(1, "Error %d connecting to server via ipv4", rc);
2176 sock_release(socket);
2177 server->ssocket = NULL;
2183 * Eventually check for other socket options to change from
2184 * the default. sock_setsockopt not used because it expects
2187 socket->sk->sk_rcvtimeo = 7 * HZ;
2188 socket->sk->sk_sndtimeo = 5 * HZ;
2190 /* make the bufsizes depend on wsize/rsize and max requests */
2191 if (server->noautotune) {
2192 if (socket->sk->sk_sndbuf < (200 * 1024))
2193 socket->sk->sk_sndbuf = 200 * 1024;
2194 if (socket->sk->sk_rcvbuf < (140 * 1024))
2195 socket->sk->sk_rcvbuf = 140 * 1024;
2198 if (server->tcp_nodelay) {
2200 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2201 (char *)&val, sizeof(val));
2203 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2206 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2207 socket->sk->sk_sndbuf,
2208 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2210 /* send RFC1001 sessinit */
2211 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
2212 /* some servers require RFC1001 sessinit before sending
2213 negprot - BB check reconnection in case where second
2214 sessinit is sent but no second negprot */
2215 struct rfc1002_session_packet *ses_init_buf;
2216 struct smb_hdr *smb_buf;
2217 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2220 ses_init_buf->trailer.session_req.called_len = 32;
2221 if (server->server_RFC1001_name &&
2222 server->server_RFC1001_name[0] != 0)
2223 rfc1002mangle(ses_init_buf->trailer.
2224 session_req.called_name,
2225 server->server_RFC1001_name,
2226 RFC1001_NAME_LEN_WITH_NULL);
2228 rfc1002mangle(ses_init_buf->trailer.
2229 session_req.called_name,
2230 DEFAULT_CIFS_CALLED_NAME,
2231 RFC1001_NAME_LEN_WITH_NULL);
2233 ses_init_buf->trailer.session_req.calling_len = 32;
2235 /* calling name ends in null (byte 16) from old smb
2237 if (server->workstation_RFC1001_name &&
2238 server->workstation_RFC1001_name[0] != 0)
2239 rfc1002mangle(ses_init_buf->trailer.
2240 session_req.calling_name,
2241 server->workstation_RFC1001_name,
2242 RFC1001_NAME_LEN_WITH_NULL);
2244 rfc1002mangle(ses_init_buf->trailer.
2245 session_req.calling_name,
2247 RFC1001_NAME_LEN_WITH_NULL);
2249 ses_init_buf->trailer.session_req.scope1 = 0;
2250 ses_init_buf->trailer.session_req.scope2 = 0;
2251 smb_buf = (struct smb_hdr *)ses_init_buf;
2252 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2253 smb_buf->smb_buf_length = 0x81000044;
2254 rc = smb_send(server, smb_buf, 0x44);
2255 kfree(ses_init_buf);
2256 msleep(1); /* RFC1001 layer in at least one server
2257 requires very short break before negprot
2258 presumably because not expecting negprot
2259 to follow so fast. This is a simple
2260 solution that works without
2261 complicating the code and causes no
2262 significant slowing down on mount
2263 for everyone else */
2265 /* else the negprot may still work without this
2266 even though malloc failed */
2274 ipv6_connect(struct TCP_Server_Info *server)
2278 bool connected = false;
2279 __be16 orig_port = 0;
2280 struct socket *socket = server->ssocket;
2282 if (socket == NULL) {
2283 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
2284 IPPROTO_TCP, &socket);
2286 cERROR(1, "Error %d creating ipv6 socket", rc);
2291 /* BB other socket options to set KEEPALIVE, NODELAY? */
2292 cFYI(1, "ipv6 Socket created");
2293 server->ssocket = socket;
2294 socket->sk->sk_allocation = GFP_NOFS;
2295 cifs_reclassify_socket6(socket);
2298 rc = bind_socket(server);
2302 /* user overrode default port */
2303 if (server->addr.sockAddr6.sin6_port) {
2304 rc = socket->ops->connect(socket,
2305 (struct sockaddr *) &server->addr.sockAddr6,
2306 sizeof(struct sockaddr_in6), 0);
2312 /* save original port so we can retry user specified port
2313 later if fall back ports fail this time */
2315 orig_port = server->addr.sockAddr6.sin6_port;
2316 /* do not retry on the same port we just failed on */
2317 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
2318 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
2319 rc = socket->ops->connect(socket, (struct sockaddr *)
2320 &server->addr.sockAddr6,
2321 sizeof(struct sockaddr_in6), 0);
2327 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
2328 rc = socket->ops->connect(socket, (struct sockaddr *)
2329 &server->addr.sockAddr6,
2330 sizeof(struct sockaddr_in6), 0);
2335 /* give up here - unless we want to retry on different
2336 protocol families some day */
2339 server->addr.sockAddr6.sin6_port = orig_port;
2340 cFYI(1, "Error %d connecting to server via ipv6", rc);
2341 sock_release(socket);
2342 server->ssocket = NULL;
2347 * Eventually check for other socket options to change from
2348 * the default. sock_setsockopt not used because it expects
2351 socket->sk->sk_rcvtimeo = 7 * HZ;
2352 socket->sk->sk_sndtimeo = 5 * HZ;
2354 if (server->tcp_nodelay) {
2356 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2357 (char *)&val, sizeof(val));
2359 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2362 server->ssocket = socket;
2367 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2368 struct super_block *sb, struct smb_vol *vol_info)
2370 /* if we are reconnecting then should we check to see if
2371 * any requested capabilities changed locally e.g. via
2372 * remount but we can not do much about it here
2373 * if they have (even if we could detect it by the following)
2374 * Perhaps we could add a backpointer to array of sb from tcon
2375 * or if we change to make all sb to same share the same
2376 * sb as NFS - then we only have one backpointer to sb.
2377 * What if we wanted to mount the server share twice once with
2378 * and once without posixacls or posix paths? */
2379 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2381 if (vol_info && vol_info->no_linux_ext) {
2382 tcon->fsUnixInfo.Capability = 0;
2383 tcon->unix_ext = 0; /* Unix Extensions disabled */
2384 cFYI(1, "Linux protocol extensions disabled");
2386 } else if (vol_info)
2387 tcon->unix_ext = 1; /* Unix Extensions supported */
2389 if (tcon->unix_ext == 0) {
2390 cFYI(1, "Unix extensions disabled so not set on reconnect");
2394 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2395 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2397 /* check for reconnect case in which we do not
2398 want to change the mount behavior if we can avoid it */
2399 if (vol_info == NULL) {
2400 /* turn off POSIX ACL and PATHNAMES if not set
2401 originally at mount time */
2402 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2403 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2404 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2405 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2406 cERROR(1, "POSIXPATH support change");
2407 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2408 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2409 cERROR(1, "possible reconnect error");
2410 cERROR(1, "server disabled POSIX path support");
2414 cap &= CIFS_UNIX_CAP_MASK;
2415 if (vol_info && vol_info->no_psx_acl)
2416 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2417 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2418 cFYI(1, "negotiated posix acl support");
2420 sb->s_flags |= MS_POSIXACL;
2423 if (vol_info && vol_info->posix_paths == 0)
2424 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2425 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2426 cFYI(1, "negotiate posix pathnames");
2428 CIFS_SB(sb)->mnt_cifs_flags |=
2429 CIFS_MOUNT_POSIX_PATHS;
2432 /* We might be setting the path sep back to a different
2433 form if we are reconnecting and the server switched its
2434 posix path capability for this share */
2435 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2436 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2438 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2439 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2440 CIFS_SB(sb)->rsize = 127 * 1024;
2441 cFYI(DBG2, "larger reads not supported by srv");
2446 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2447 #ifdef CONFIG_CIFS_DEBUG2
2448 if (cap & CIFS_UNIX_FCNTL_CAP)
2449 cFYI(1, "FCNTL cap");
2450 if (cap & CIFS_UNIX_EXTATTR_CAP)
2451 cFYI(1, "EXTATTR cap");
2452 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2453 cFYI(1, "POSIX path cap");
2454 if (cap & CIFS_UNIX_XATTR_CAP)
2455 cFYI(1, "XATTR cap");
2456 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2457 cFYI(1, "POSIX ACL cap");
2458 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2459 cFYI(1, "very large read cap");
2460 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2461 cFYI(1, "very large write cap");
2462 #endif /* CIFS_DEBUG2 */
2463 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2464 if (vol_info == NULL) {
2465 cFYI(1, "resetting capabilities failed");
2467 cERROR(1, "Negotiating Unix capabilities "
2468 "with the server failed. Consider "
2469 "mounting with the Unix Extensions\n"
2470 "disabled, if problems are found, "
2471 "by specifying the nounix mount "
2479 convert_delimiter(char *path, char delim)
2492 for (i = 0; path[i] != '\0'; i++) {
2493 if (path[i] == old_delim)
2498 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2499 struct cifs_sb_info *cifs_sb)
2501 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2503 if (pvolume_info->rsize > CIFSMaxBufSize) {
2504 cERROR(1, "rsize %d too large, using MaxBufSize",
2505 pvolume_info->rsize);
2506 cifs_sb->rsize = CIFSMaxBufSize;
2507 } else if ((pvolume_info->rsize) &&
2508 (pvolume_info->rsize <= CIFSMaxBufSize))
2509 cifs_sb->rsize = pvolume_info->rsize;
2511 cifs_sb->rsize = CIFSMaxBufSize;
2513 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2514 cERROR(1, "wsize %d too large, using 4096 instead",
2515 pvolume_info->wsize);
2516 cifs_sb->wsize = 4096;
2517 } else if (pvolume_info->wsize)
2518 cifs_sb->wsize = pvolume_info->wsize;
2520 cifs_sb->wsize = min_t(const int,
2521 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2523 /* old default of CIFSMaxBufSize was too small now
2524 that SMB Write2 can send multiple pages in kvec.
2525 RFC1001 does not describe what happens when frame
2526 bigger than 128K is sent so use that as max in
2527 conjunction with 52K kvec constraint on arch with 4K
2530 if (cifs_sb->rsize < 2048) {
2531 cifs_sb->rsize = 2048;
2532 /* Windows ME may prefer this */
2533 cFYI(1, "readsize set to minimum: 2048");
2535 /* calculate prepath */
2536 cifs_sb->prepath = pvolume_info->prepath;
2537 if (cifs_sb->prepath) {
2538 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2539 /* we can not convert the / to \ in the path
2540 separators in the prefixpath yet because we do not
2541 know (until reset_cifs_unix_caps is called later)
2542 whether POSIX PATH CAP is available. We normalize
2543 the / to \ after reset_cifs_unix_caps is called */
2544 pvolume_info->prepath = NULL;
2546 cifs_sb->prepathlen = 0;
2547 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2548 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2549 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2550 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2551 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2552 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2554 if (pvolume_info->noperm)
2555 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2556 if (pvolume_info->setuids)
2557 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2558 if (pvolume_info->server_ino)
2559 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2560 if (pvolume_info->remap)
2561 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2562 if (pvolume_info->no_xattr)
2563 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2564 if (pvolume_info->sfu_emul)
2565 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2566 if (pvolume_info->nobrl)
2567 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2568 if (pvolume_info->nostrictsync)
2569 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2570 if (pvolume_info->mand_lock)
2571 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2572 if (pvolume_info->cifs_acl)
2573 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2574 if (pvolume_info->override_uid)
2575 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2576 if (pvolume_info->override_gid)
2577 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2578 if (pvolume_info->dynperm)
2579 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2580 if (pvolume_info->fsc)
2581 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2582 if (pvolume_info->multiuser)
2583 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2584 CIFS_MOUNT_NO_PERM);
2585 if (pvolume_info->direct_io) {
2586 cFYI(1, "mounting share using direct i/o");
2587 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2589 if (pvolume_info->mfsymlinks) {
2590 if (pvolume_info->sfu_emul) {
2591 cERROR(1, "mount option mfsymlinks ignored if sfu "
2592 "mount option is used");
2594 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2598 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2599 cERROR(1, "mount option dynperm ignored if cifsacl "
2600 "mount option supported");
2604 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2605 struct cifs_sb_info *cifs_sb, const char *full_path)
2608 FILE_ALL_INFO *pfile_info;
2610 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2611 if (pfile_info == NULL)
2614 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2615 0 /* not legacy */, cifs_sb->local_nls,
2616 cifs_sb->mnt_cifs_flags &
2617 CIFS_MOUNT_MAP_SPECIAL_CHR);
2623 cleanup_volume_info(struct smb_vol **pvolume_info)
2625 struct smb_vol *volume_info;
2627 if (!pvolume_info || !*pvolume_info)
2630 volume_info = *pvolume_info;
2631 kzfree(volume_info->password);
2632 kfree(volume_info->UNC);
2633 kfree(volume_info->prepath);
2635 *pvolume_info = NULL;
2639 #ifdef CONFIG_CIFS_DFS_UPCALL
2640 /* build_path_to_root returns full path to root when
2641 * we do not have an exiting connection (tcon) */
2643 build_unc_path_to_root(const struct smb_vol *volume_info,
2644 const struct cifs_sb_info *cifs_sb)
2648 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2649 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2650 if (full_path == NULL)
2651 return ERR_PTR(-ENOMEM);
2653 strncpy(full_path, volume_info->UNC, unc_len);
2654 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2656 for (i = 0; i < unc_len; i++) {
2657 if (full_path[i] == '\\')
2662 if (cifs_sb->prepathlen)
2663 strncpy(full_path + unc_len, cifs_sb->prepath,
2664 cifs_sb->prepathlen);
2666 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2672 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2673 char *mount_data_global, const char *devname)
2677 struct smb_vol *volume_info;
2678 struct cifsSesInfo *pSesInfo;
2679 struct cifsTconInfo *tcon;
2680 struct TCP_Server_Info *srvTcp;
2682 char *mount_data = mount_data_global;
2683 struct tcon_link *tlink;
2684 #ifdef CONFIG_CIFS_DFS_UPCALL
2685 struct dfs_info3_param *referrals = NULL;
2686 unsigned int num_referrals = 0;
2687 int referral_walks_count = 0;
2699 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2705 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2710 if (volume_info->nullauth) {
2711 cFYI(1, "null user");
2712 volume_info->username = "";
2713 } else if (volume_info->username) {
2714 /* BB fixme parse for domain name here */
2715 cFYI(1, "Username: %s", volume_info->username);
2717 cifserror("No username specified");
2718 /* In userspace mount helper we can get user name from alternate
2719 locations such as env variables and files on disk */
2724 /* this is needed for ASCII cp to Unicode converts */
2725 if (volume_info->iocharset == NULL) {
2726 /* load_nls_default cannot return null */
2727 volume_info->local_nls = load_nls_default();
2729 volume_info->local_nls = load_nls(volume_info->iocharset);
2730 if (volume_info->local_nls == NULL) {
2731 cERROR(1, "CIFS mount error: iocharset %s not found",
2732 volume_info->iocharset);
2737 cifs_sb->local_nls = volume_info->local_nls;
2739 /* get a reference to a tcp session */
2740 srvTcp = cifs_get_tcp_session(volume_info);
2741 if (IS_ERR(srvTcp)) {
2742 rc = PTR_ERR(srvTcp);
2746 /* get a reference to a SMB session */
2747 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2748 if (IS_ERR(pSesInfo)) {
2749 rc = PTR_ERR(pSesInfo);
2751 goto mount_fail_check;
2754 setup_cifs_sb(volume_info, cifs_sb);
2755 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2756 sb->s_maxbytes = MAX_LFS_FILESIZE;
2758 sb->s_maxbytes = MAX_NON_LFS;
2760 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2761 sb->s_time_gran = 100;
2763 /* search for existing tcon to this server share */
2764 tcon = cifs_get_tcon(pSesInfo, volume_info);
2768 goto remote_path_check;
2771 /* do not care if following two calls succeed - informational */
2773 CIFSSMBQFSDeviceInfo(xid, tcon);
2774 CIFSSMBQFSAttributeInfo(xid, tcon);
2777 /* tell server which Unix caps we support */
2778 if (tcon->ses->capabilities & CAP_UNIX)
2779 /* reset of caps checks mount to see if unix extensions
2780 disabled for just this mount */
2781 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2783 tcon->unix_ext = 0; /* server does not support them */
2785 /* convert forward to back slashes in prepath here if needed */
2786 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2787 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2789 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2790 cifs_sb->rsize = 1024 * 127;
2791 cFYI(DBG2, "no very large read support, rsize now 127K");
2793 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2794 cifs_sb->wsize = min(cifs_sb->wsize,
2795 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2796 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2797 cifs_sb->rsize = min(cifs_sb->rsize,
2798 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2801 /* check if a whole path (including prepath) is not remote */
2802 if (!rc && cifs_sb->prepathlen && tcon) {
2803 /* build_path_to_root works only when we have a valid tcon */
2804 full_path = cifs_build_path_to_root(cifs_sb);
2805 if (full_path == NULL) {
2807 goto mount_fail_check;
2809 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2810 if (rc != -EREMOTE) {
2812 goto mount_fail_check;
2817 /* get referral if needed */
2818 if (rc == -EREMOTE) {
2819 #ifdef CONFIG_CIFS_DFS_UPCALL
2820 if (referral_walks_count > MAX_NESTED_LINKS) {
2822 * BB: when we implement proper loop detection,
2823 * we will remove this check. But now we need it
2824 * to prevent an indefinite loop if 'DFS tree' is
2825 * misconfigured (i.e. has loops).
2828 goto mount_fail_check;
2830 /* convert forward to back slashes in prepath here if needed */
2831 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2832 convert_delimiter(cifs_sb->prepath,
2833 CIFS_DIR_SEP(cifs_sb));
2834 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2835 if (IS_ERR(full_path)) {
2836 rc = PTR_ERR(full_path);
2837 goto mount_fail_check;
2840 cFYI(1, "Getting referral for: %s", full_path);
2841 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2842 cifs_sb->local_nls, &num_referrals, &referrals,
2843 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2844 if (!rc && num_referrals > 0) {
2845 char *fake_devname = NULL;
2847 if (mount_data != mount_data_global)
2850 mount_data = cifs_compose_mount_options(
2851 cifs_sb->mountdata, full_path + 1,
2852 referrals, &fake_devname);
2854 free_dfs_info_array(referrals, num_referrals);
2855 kfree(fake_devname);
2858 if (IS_ERR(mount_data)) {
2859 rc = PTR_ERR(mount_data);
2861 goto mount_fail_check;
2865 cifs_put_tcon(tcon);
2867 cifs_put_smb_ses(pSesInfo);
2869 cleanup_volume_info(&volume_info);
2870 referral_walks_count++;
2872 goto try_mount_again;
2874 #else /* No DFS support, return error on mount */
2880 goto mount_fail_check;
2882 /* now, hang the tcon off of the superblock */
2883 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2884 if (tlink == NULL) {
2886 goto mount_fail_check;
2889 tlink->tl_index = pSesInfo->linux_uid;
2890 tlink->tl_tcon = tcon;
2891 tlink->tl_time = jiffies;
2892 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2893 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2895 rc = radix_tree_preload(GFP_KERNEL);
2896 if (rc == -ENOMEM) {
2898 goto mount_fail_check;
2901 spin_lock(&cifs_sb->tlink_tree_lock);
2902 radix_tree_insert(&cifs_sb->tlink_tree, pSesInfo->linux_uid, tlink);
2903 radix_tree_tag_set(&cifs_sb->tlink_tree, pSesInfo->linux_uid,
2904 CIFS_TLINK_MASTER_TAG);
2905 spin_unlock(&cifs_sb->tlink_tree_lock);
2906 radix_tree_preload_end();
2908 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2912 /* on error free sesinfo and tcon struct if needed */
2914 if (mount_data != mount_data_global)
2916 /* If find_unc succeeded then rc == 0 so we can not end */
2917 /* up accidently freeing someone elses tcon struct */
2919 cifs_put_tcon(tcon);
2921 cifs_put_smb_ses(pSesInfo);
2923 cifs_put_tcp_session(srvTcp);
2927 /* volume_info->password is freed above when existing session found
2928 (in which case it is not needed anymore) but when new sesion is created
2929 the password ptr is put in the new session structure (in which case the
2930 password will be freed at unmount time) */
2932 /* zero out password before freeing */
2933 cleanup_volume_info(&volume_info);
2939 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2940 const char *tree, struct cifsTconInfo *tcon,
2941 const struct nls_table *nls_codepage)
2943 struct smb_hdr *smb_buffer;
2944 struct smb_hdr *smb_buffer_response;
2947 unsigned char *bcc_ptr;
2949 int length, bytes_left;
2955 smb_buffer = cifs_buf_get();
2956 if (smb_buffer == NULL)
2959 smb_buffer_response = smb_buffer;
2961 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2962 NULL /*no tid */ , 4 /*wct */ );
2964 smb_buffer->Mid = GetNextMid(ses->server);
2965 smb_buffer->Uid = ses->Suid;
2966 pSMB = (TCONX_REQ *) smb_buffer;
2967 pSMBr = (TCONX_RSP *) smb_buffer_response;
2969 pSMB->AndXCommand = 0xFF;
2970 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2971 bcc_ptr = &pSMB->Password[0];
2972 if ((ses->server->secMode) & SECMODE_USER) {
2973 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
2974 *bcc_ptr = 0; /* password is null byte */
2975 bcc_ptr++; /* skip password */
2976 /* already aligned so no need to do it below */
2978 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
2979 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2980 specified as required (when that support is added to
2981 the vfs in the future) as only NTLM or the much
2982 weaker LANMAN (which we do not send by default) is accepted
2983 by Samba (not sure whether other servers allow
2984 NTLMv2 password here) */
2985 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2986 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
2987 (ses->server->secType == LANMAN))
2988 calc_lanman_hash(tcon->password, ses->cryptKey,
2989 ses->server->secMode &
2990 SECMODE_PW_ENCRYPT ? true : false,
2993 #endif /* CIFS_WEAK_PW_HASH */
2994 SMBNTencrypt(tcon->password, ses->cryptKey, bcc_ptr);
2996 bcc_ptr += CIFS_SESS_KEY_SIZE;
2997 if (ses->capabilities & CAP_UNICODE) {
2998 /* must align unicode strings */
2999 *bcc_ptr = 0; /* null byte password */
3004 if (ses->server->secMode &
3005 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3006 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3008 if (ses->capabilities & CAP_STATUS32) {
3009 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3011 if (ses->capabilities & CAP_DFS) {
3012 smb_buffer->Flags2 |= SMBFLG2_DFS;
3014 if (ses->capabilities & CAP_UNICODE) {
3015 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3017 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3018 6 /* max utf8 char length in bytes */ *
3019 (/* server len*/ + 256 /* share len */), nls_codepage);
3020 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3021 bcc_ptr += 2; /* skip trailing null */
3022 } else { /* ASCII */
3023 strcpy(bcc_ptr, tree);
3024 bcc_ptr += strlen(tree) + 1;
3026 strcpy(bcc_ptr, "?????");
3027 bcc_ptr += strlen("?????");
3029 count = bcc_ptr - &pSMB->Password[0];
3030 pSMB->hdr.smb_buf_length += count;
3031 pSMB->ByteCount = cpu_to_le16(count);
3033 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3036 /* above now done in SendReceive */
3037 if ((rc == 0) && (tcon != NULL)) {
3040 tcon->tidStatus = CifsGood;
3041 tcon->need_reconnect = false;
3042 tcon->tid = smb_buffer_response->Tid;
3043 bcc_ptr = pByteArea(smb_buffer_response);
3044 bytes_left = BCC(smb_buffer_response);
3045 length = strnlen(bcc_ptr, bytes_left - 2);
3046 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3052 /* skip service field (NB: this field is always ASCII) */
3054 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3055 (bcc_ptr[2] == 'C')) {
3056 cFYI(1, "IPC connection");
3059 } else if (length == 2) {
3060 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3061 /* the most common case */
3062 cFYI(1, "disk share connection");
3065 bcc_ptr += length + 1;
3066 bytes_left -= (length + 1);
3067 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3069 /* mostly informational -- no need to fail on error here */
3070 kfree(tcon->nativeFileSystem);
3071 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3072 bytes_left, is_unicode,
3075 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3077 if ((smb_buffer_response->WordCount == 3) ||
3078 (smb_buffer_response->WordCount == 7))
3079 /* field is in same location */
3080 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3083 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3084 } else if ((rc == 0) && tcon == NULL) {
3085 /* all we need to save for IPC$ connection */
3086 ses->ipc_tid = smb_buffer_response->Tid;
3089 cifs_buf_release(smb_buffer);
3094 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3098 struct tcon_link *tlink[8];
3099 unsigned long index = 0;
3101 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3104 spin_lock(&cifs_sb->tlink_tree_lock);
3105 ret = radix_tree_gang_lookup(&cifs_sb->tlink_tree,
3106 (void **)tlink, index,
3108 /* increment index for next pass */
3110 index = tlink[ret - 1]->tl_index + 1;
3111 for (i = 0; i < ret; i++) {
3112 cifs_get_tlink(tlink[i]);
3113 clear_bit(TCON_LINK_IN_TREE, &tlink[i]->tl_flags);
3114 radix_tree_delete(&cifs_sb->tlink_tree,
3115 tlink[i]->tl_index);
3117 spin_unlock(&cifs_sb->tlink_tree_lock);
3119 for (i = 0; i < ret; i++)
3120 cifs_put_tlink(tlink[i]);
3123 tmp = cifs_sb->prepath;
3124 cifs_sb->prepathlen = 0;
3125 cifs_sb->prepath = NULL;
3131 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3134 struct TCP_Server_Info *server = ses->server;
3136 /* only send once per connect */
3137 if (server->maxBuf != 0)
3140 rc = CIFSSMBNegotiate(xid, ses);
3141 if (rc == -EAGAIN) {
3142 /* retry only once on 1st time connection */
3143 rc = CIFSSMBNegotiate(xid, ses);
3148 spin_lock(&GlobalMid_Lock);
3149 if (server->tcpStatus != CifsExiting)
3150 server->tcpStatus = CifsGood;
3153 spin_unlock(&GlobalMid_Lock);
3161 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3162 struct nls_table *nls_info)
3165 struct TCP_Server_Info *server = ses->server;
3168 ses->capabilities = server->capabilities;
3169 if (linuxExtEnabled == 0)
3170 ses->capabilities &= (~CAP_UNIX);
3172 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3173 server->secMode, server->capabilities, server->timeAdj);
3175 rc = CIFS_SessSetup(xid, ses, nls_info);
3177 cERROR(1, "Send error in SessSetup = %d", rc);
3179 mutex_lock(&ses->server->srv_mutex);
3180 if (!server->session_estab) {
3181 memcpy(&server->session_key.data,
3182 &ses->auth_key.data, ses->auth_key.len);
3183 server->session_key.len = ses->auth_key.len;
3184 ses->server->session_estab = true;
3186 mutex_unlock(&server->srv_mutex);
3188 cFYI(1, "CIFS Session Established successfully");
3189 spin_lock(&GlobalMid_Lock);
3190 ses->status = CifsGood;
3191 ses->need_reconnect = false;
3192 spin_unlock(&GlobalMid_Lock);
3198 static struct cifsTconInfo *
3199 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3201 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3202 struct cifsSesInfo *ses;
3203 struct cifsTconInfo *tcon = NULL;
3204 struct smb_vol *vol_info;
3205 char username[MAX_USERNAME_SIZE + 1];
3207 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3208 if (vol_info == NULL) {
3209 tcon = ERR_PTR(-ENOMEM);
3213 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3214 vol_info->username = username;
3215 vol_info->local_nls = cifs_sb->local_nls;
3216 vol_info->linux_uid = fsuid;
3217 vol_info->cred_uid = fsuid;
3218 vol_info->UNC = master_tcon->treeName;
3219 vol_info->retry = master_tcon->retry;
3220 vol_info->nocase = master_tcon->nocase;
3221 vol_info->local_lease = master_tcon->local_lease;
3222 vol_info->no_linux_ext = !master_tcon->unix_ext;
3224 /* FIXME: allow for other secFlg settings */
3225 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3227 /* get a reference for the same TCP session */
3228 spin_lock(&cifs_tcp_ses_lock);
3229 ++master_tcon->ses->server->srv_count;
3230 spin_unlock(&cifs_tcp_ses_lock);
3232 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3234 tcon = (struct cifsTconInfo *)ses;
3235 cifs_put_tcp_session(master_tcon->ses->server);
3239 tcon = cifs_get_tcon(ses, vol_info);
3241 cifs_put_smb_ses(ses);
3245 if (ses->capabilities & CAP_UNIX)
3246 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3253 static struct tcon_link *
3254 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3256 struct tcon_link *tlink;
3259 spin_lock(&cifs_sb->tlink_tree_lock);
3260 ret = radix_tree_gang_lookup_tag(&cifs_sb->tlink_tree, (void **)&tlink,
3261 0, 1, CIFS_TLINK_MASTER_TAG);
3262 spin_unlock(&cifs_sb->tlink_tree_lock);
3264 /* the master tcon should always be present */
3271 struct cifsTconInfo *
3272 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3274 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3278 cifs_sb_tcon_pending_wait(void *unused)
3281 return signal_pending(current) ? -ERESTARTSYS : 0;
3285 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3288 * If the superblock doesn't refer to a multiuser mount, then just return
3289 * the master tcon for the mount.
3291 * First, search the radix tree for an existing tcon for this fsuid. If one
3292 * exists, then check to see if it's pending construction. If it is then wait
3293 * for construction to complete. Once it's no longer pending, check to see if
3294 * it failed and either return an error or retry construction, depending on
3297 * If one doesn't exist then insert a new tcon_link struct into the tree and
3298 * try to construct a new one.
3301 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3304 unsigned long fsuid = (unsigned long) current_fsuid();
3305 struct tcon_link *tlink, *newtlink;
3307 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3308 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3310 spin_lock(&cifs_sb->tlink_tree_lock);
3311 tlink = radix_tree_lookup(&cifs_sb->tlink_tree, fsuid);
3313 cifs_get_tlink(tlink);
3314 spin_unlock(&cifs_sb->tlink_tree_lock);
3316 if (tlink == NULL) {
3317 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3318 if (newtlink == NULL)
3319 return ERR_PTR(-ENOMEM);
3320 newtlink->tl_index = fsuid;
3321 newtlink->tl_tcon = ERR_PTR(-EACCES);
3322 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3323 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3324 cifs_get_tlink(newtlink);
3326 ret = radix_tree_preload(GFP_KERNEL);
3329 return ERR_PTR(ret);
3332 spin_lock(&cifs_sb->tlink_tree_lock);
3333 /* was one inserted after previous search? */
3334 tlink = radix_tree_lookup(&cifs_sb->tlink_tree, fsuid);
3336 cifs_get_tlink(tlink);
3337 spin_unlock(&cifs_sb->tlink_tree_lock);
3338 radix_tree_preload_end();
3340 goto wait_for_construction;
3342 ret = radix_tree_insert(&cifs_sb->tlink_tree, fsuid, newtlink);
3343 spin_unlock(&cifs_sb->tlink_tree_lock);
3344 radix_tree_preload_end();
3347 return ERR_PTR(ret);
3351 wait_for_construction:
3352 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3353 cifs_sb_tcon_pending_wait,
3354 TASK_INTERRUPTIBLE);
3356 cifs_put_tlink(tlink);
3357 return ERR_PTR(ret);
3360 /* if it's good, return it */
3361 if (!IS_ERR(tlink->tl_tcon))
3364 /* return error if we tried this already recently */
3365 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3366 cifs_put_tlink(tlink);
3367 return ERR_PTR(-EACCES);
3370 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3371 goto wait_for_construction;
3374 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3375 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3376 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3378 if (IS_ERR(tlink->tl_tcon)) {
3379 cifs_put_tlink(tlink);
3380 return ERR_PTR(-EACCES);
3387 * periodic workqueue job that scans tcon_tree for a superblock and closes
3391 cifs_prune_tlinks(struct work_struct *work)
3393 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3395 struct tcon_link *tlink[8];
3396 unsigned long now = jiffies;
3397 unsigned long index = 0;
3401 spin_lock(&cifs_sb->tlink_tree_lock);
3402 ret = radix_tree_gang_lookup(&cifs_sb->tlink_tree,
3403 (void **)tlink, index,
3405 /* increment index for next pass */
3407 index = tlink[ret - 1]->tl_index + 1;
3408 for (i = 0; i < ret; i++) {
3409 if (test_bit(TCON_LINK_MASTER, &tlink[i]->tl_flags) ||
3410 atomic_read(&tlink[i]->tl_count) != 0 ||
3411 time_after(tlink[i]->tl_time + TLINK_IDLE_EXPIRE,
3416 cifs_get_tlink(tlink[i]);
3417 clear_bit(TCON_LINK_IN_TREE, &tlink[i]->tl_flags);
3418 radix_tree_delete(&cifs_sb->tlink_tree,
3419 tlink[i]->tl_index);
3421 spin_unlock(&cifs_sb->tlink_tree_lock);
3423 for (i = 0; i < ret; i++) {
3424 if (tlink[i] != NULL)
3425 cifs_put_tlink(tlink[i]);
3429 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,