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 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
58 extern mempool_t *cifs_req_poolp;
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
68 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
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 strict_io:1; /* strict cache behavior */
88 bool remap:1; /* set to remap seven reserved chars in filenames */
89 bool posix_paths:1; /* unset to not ask for posix pathnames. */
92 bool nullauth:1; /* attempt to authenticate with null user */
93 bool nocase:1; /* request case insensitive filenames */
94 bool nobrl:1; /* disable sending byte range locks to srv */
95 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
96 bool seal:1; /* request transport encryption on share */
97 bool nodfs:1; /* Do not request DFS, even if available */
98 bool local_lease:1; /* check leases only on local system, not remote */
101 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
102 bool fsc:1; /* enable fscache */
103 bool mfsymlinks:1; /* use Minshall+French Symlinks */
107 bool sockopt_tcp_nodelay:1;
108 unsigned short int port;
109 unsigned long actimeo; /* attribute cache timeout (jiffies) */
111 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
112 struct nls_table *local_nls;
115 /* FIXME: should these be tunable? */
116 #define TLINK_ERROR_EXPIRE (1 * HZ)
117 #define TLINK_IDLE_EXPIRE (600 * HZ)
119 static int ip_connect(struct TCP_Server_Info *server);
120 static int generic_ip_connect(struct TCP_Server_Info *server);
121 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
122 static void cifs_prune_tlinks(struct work_struct *work);
125 * cifs tcp session reconnection
127 * mark tcp session as reconnecting so temporarily locked
128 * mark all smb sessions as reconnecting for tcp session
129 * reconnect tcp session
130 * wake up waiters on reconnection? - (not needed currently)
133 cifs_reconnect(struct TCP_Server_Info *server)
136 struct list_head *tmp, *tmp2;
137 struct cifsSesInfo *ses;
138 struct cifsTconInfo *tcon;
139 struct mid_q_entry *mid_entry;
141 spin_lock(&GlobalMid_Lock);
142 if (server->tcpStatus == CifsExiting) {
143 /* the demux thread will exit normally
144 next time through the loop */
145 spin_unlock(&GlobalMid_Lock);
148 server->tcpStatus = CifsNeedReconnect;
149 spin_unlock(&GlobalMid_Lock);
152 cFYI(1, "Reconnecting tcp session");
154 /* before reconnecting the tcp session, mark the smb session (uid)
155 and the tid bad so they are not used until reconnected */
156 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
157 spin_lock(&cifs_tcp_ses_lock);
158 list_for_each(tmp, &server->smb_ses_list) {
159 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
160 ses->need_reconnect = true;
162 list_for_each(tmp2, &ses->tcon_list) {
163 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
164 tcon->need_reconnect = true;
167 spin_unlock(&cifs_tcp_ses_lock);
169 /* do not want to be sending data on a socket we are freeing */
170 cFYI(1, "%s: tearing down socket", __func__);
171 mutex_lock(&server->srv_mutex);
172 if (server->ssocket) {
173 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
174 server->ssocket->flags);
175 kernel_sock_shutdown(server->ssocket, SHUT_WR);
176 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
177 server->ssocket->state,
178 server->ssocket->flags);
179 sock_release(server->ssocket);
180 server->ssocket = NULL;
182 server->sequence_number = 0;
183 server->session_estab = false;
184 kfree(server->session_key.response);
185 server->session_key.response = NULL;
186 server->session_key.len = 0;
187 server->lstrp = jiffies;
188 mutex_unlock(&server->srv_mutex);
190 /* mark submitted MIDs for retry and issue callback */
191 cFYI(1, "%s: issuing mid callbacks", __func__);
192 spin_lock(&GlobalMid_Lock);
193 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
194 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
195 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
196 mid_entry->midState = MID_RETRY_NEEDED;
197 list_del_init(&mid_entry->qhead);
198 mid_entry->callback(mid_entry);
200 spin_unlock(&GlobalMid_Lock);
202 while ((server->tcpStatus != CifsExiting) &&
203 (server->tcpStatus != CifsGood)) {
206 /* we should try only the port we connected to before */
207 rc = generic_ip_connect(server);
209 cFYI(1, "reconnect error %d", rc);
212 atomic_inc(&tcpSesReconnectCount);
213 spin_lock(&GlobalMid_Lock);
214 if (server->tcpStatus != CifsExiting)
215 server->tcpStatus = CifsGood;
216 spin_unlock(&GlobalMid_Lock);
225 0 not a transact2, or all data present
226 >0 transact2 with that much data missing
227 -EINVAL = invalid transact2
230 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
232 struct smb_t2_rsp *pSMBt;
234 __u16 total_data_size, data_in_this_rsp;
236 if (pSMB->Command != SMB_COM_TRANSACTION2)
239 /* check for plausible wct, bcc and t2 data and parm sizes */
240 /* check for parm and data offset going beyond end of smb */
241 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
242 cFYI(1, "invalid transact2 word count");
246 pSMBt = (struct smb_t2_rsp *)pSMB;
248 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
249 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
251 remaining = total_data_size - data_in_this_rsp;
255 else if (remaining < 0) {
256 cFYI(1, "total data %d smaller than data in frame %d",
257 total_data_size, data_in_this_rsp);
260 cFYI(1, "missing %d bytes from transact2, check next response",
262 if (total_data_size > maxBufSize) {
263 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
264 total_data_size, maxBufSize);
271 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
273 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
274 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
275 char *data_area_of_target;
276 char *data_area_of_buf2;
278 __u16 byte_count, total_data_size, total_in_buf, total_in_buf2;
280 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
282 if (total_data_size !=
283 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
284 cFYI(1, "total data size of primary and secondary t2 differ");
286 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
288 remaining = total_data_size - total_in_buf;
293 if (remaining == 0) /* nothing to do, ignore */
296 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
297 if (remaining < total_in_buf2) {
298 cFYI(1, "transact2 2nd response contains too much data");
301 /* find end of first SMB data area */
302 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
303 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
304 /* validate target area */
306 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
307 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
309 data_area_of_target += total_in_buf;
311 /* copy second buffer into end of first buffer */
312 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
313 total_in_buf += total_in_buf2;
314 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
315 byte_count = get_bcc_le(pTargetSMB);
316 byte_count += total_in_buf2;
317 put_bcc_le(byte_count, pTargetSMB);
319 byte_count = pTargetSMB->smb_buf_length;
320 byte_count += total_in_buf2;
322 /* BB also add check that we are not beyond maximum buffer size */
324 pTargetSMB->smb_buf_length = byte_count;
326 if (remaining == total_in_buf2) {
327 cFYI(1, "found the last secondary response");
328 return 0; /* we are done */
329 } else /* more responses to go */
334 cifs_echo_request(struct work_struct *work)
337 struct TCP_Server_Info *server = container_of(work,
338 struct TCP_Server_Info, echo.work);
341 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is done.
342 * Also, no need to ping if we got a response recently
344 if (server->tcpStatus != CifsGood ||
345 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
348 rc = CIFSSMBEcho(server);
350 cFYI(1, "Unable to send echo request to server: %s",
354 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
358 cifs_demultiplex_thread(struct TCP_Server_Info *server)
361 unsigned int pdu_length, total_read;
362 struct smb_hdr *smb_buffer = NULL;
363 struct smb_hdr *bigbuf = NULL;
364 struct smb_hdr *smallbuf = NULL;
365 struct msghdr smb_msg;
367 struct socket *csocket = server->ssocket;
368 struct list_head *tmp, *tmp2;
369 struct task_struct *task_to_wake = NULL;
370 struct mid_q_entry *mid_entry;
372 bool isLargeBuf = false;
376 current->flags |= PF_MEMALLOC;
377 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
379 length = atomic_inc_return(&tcpSesAllocCount);
381 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
385 while (server->tcpStatus != CifsExiting) {
388 if (bigbuf == NULL) {
389 bigbuf = cifs_buf_get();
391 cERROR(1, "No memory for large SMB response");
393 /* retry will check if exiting */
396 } else if (isLargeBuf) {
397 /* we are reusing a dirty large buf, clear its start */
398 memset(bigbuf, 0, sizeof(struct smb_hdr));
401 if (smallbuf == NULL) {
402 smallbuf = cifs_small_buf_get();
404 cERROR(1, "No memory for SMB response");
406 /* retry will check if exiting */
409 /* beginning of smb buffer is cleared in our buf_get */
410 } else /* if existing small buf clear beginning */
411 memset(smallbuf, 0, sizeof(struct smb_hdr));
415 smb_buffer = smallbuf;
416 iov.iov_base = smb_buffer;
418 smb_msg.msg_control = NULL;
419 smb_msg.msg_controllen = 0;
420 pdu_length = 4; /* enough to get RFC1001 header */
423 if (echo_retries > 0 &&
424 time_after(jiffies, server->lstrp +
425 (echo_retries * SMB_ECHO_INTERVAL))) {
426 cERROR(1, "Server %s has not responded in %d seconds. "
427 "Reconnecting...", server->hostname,
428 (echo_retries * SMB_ECHO_INTERVAL / HZ));
429 cifs_reconnect(server);
430 csocket = server->ssocket;
431 wake_up(&server->response_q);
436 kernel_recvmsg(csocket, &smb_msg,
437 &iov, 1, pdu_length, 0 /* BB other flags? */);
439 if (server->tcpStatus == CifsExiting) {
441 } else if (server->tcpStatus == CifsNeedReconnect) {
442 cFYI(1, "Reconnect after server stopped responding");
443 cifs_reconnect(server);
444 cFYI(1, "call to reconnect done");
445 csocket = server->ssocket;
447 } else if (length == -ERESTARTSYS ||
450 msleep(1); /* minimum sleep to prevent looping
451 allowing socket to clear and app threads to set
452 tcpStatus CifsNeedReconnect if server hung */
453 if (pdu_length < 4) {
454 iov.iov_base = (4 - pdu_length) +
456 iov.iov_len = pdu_length;
457 smb_msg.msg_control = NULL;
458 smb_msg.msg_controllen = 0;
462 } else if (length <= 0) {
463 cFYI(1, "Reconnect after unexpected peek error %d",
465 cifs_reconnect(server);
466 csocket = server->ssocket;
467 wake_up(&server->response_q);
469 } else if (length < pdu_length) {
470 cFYI(1, "requested %d bytes but only got %d bytes",
472 pdu_length -= length;
477 /* The right amount was read from socket - 4 bytes */
478 /* so we can now interpret the length field */
480 /* the first byte big endian of the length field,
481 is actually not part of the length but the type
482 with the most common, zero, as regular data */
483 temp = *((char *) smb_buffer);
485 /* Note that FC 1001 length is big endian on the wire,
486 but we convert it here so it is always manipulated
487 as host byte order */
488 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
489 smb_buffer->smb_buf_length = pdu_length;
491 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
493 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
495 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
496 cFYI(1, "Good RFC 1002 session rsp");
498 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
499 /* we get this from Windows 98 instead of
500 an error on SMB negprot response */
501 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
503 /* give server a second to clean up */
505 /* always try 445 first on reconnect since we get NACK
506 * on some if we ever connected to port 139 (the NACK
507 * is since we do not begin with RFC1001 session
510 cifs_set_port((struct sockaddr *)
511 &server->dstaddr, CIFS_PORT);
512 cifs_reconnect(server);
513 csocket = server->ssocket;
514 wake_up(&server->response_q);
516 } else if (temp != (char) 0) {
517 cERROR(1, "Unknown RFC 1002 frame");
518 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
520 cifs_reconnect(server);
521 csocket = server->ssocket;
525 /* else we have an SMB response */
526 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
527 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
528 cERROR(1, "Invalid size SMB length %d pdu_length %d",
529 length, pdu_length+4);
530 cifs_reconnect(server);
531 csocket = server->ssocket;
532 wake_up(&server->response_q);
539 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
541 memcpy(bigbuf, smallbuf, 4);
545 iov.iov_base = 4 + (char *)smb_buffer;
546 iov.iov_len = pdu_length;
547 for (total_read = 0; total_read < pdu_length;
548 total_read += length) {
549 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
550 pdu_length - total_read, 0);
551 if (server->tcpStatus == CifsExiting) {
555 } else if (server->tcpStatus == CifsNeedReconnect) {
556 cifs_reconnect(server);
557 csocket = server->ssocket;
558 /* Reconnect wakes up rspns q */
559 /* Now we will reread sock */
562 } else if (length == -ERESTARTSYS ||
565 msleep(1); /* minimum sleep to prevent looping,
566 allowing socket to clear and app
567 threads to set tcpStatus
568 CifsNeedReconnect if server hung*/
571 } else if (length <= 0) {
572 cERROR(1, "Received no data, expecting %d",
573 pdu_length - total_read);
574 cifs_reconnect(server);
575 csocket = server->ssocket;
582 else if (reconnect == 1)
585 total_read += 4; /* account for rfc1002 hdr */
587 dump_smb(smb_buffer, total_read);
588 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read)) {
589 cifs_dump_mem("Bad SMB: ", smb_buffer,
590 total_read < 48 ? total_read : 48);
595 server->lstrp = jiffies;
597 spin_lock(&GlobalMid_Lock);
598 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
599 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
601 if ((mid_entry->mid == smb_buffer->Mid) &&
602 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
603 (mid_entry->command == smb_buffer->Command)) {
604 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
605 /* We have a multipart transact2 resp */
607 if (mid_entry->resp_buf) {
608 /* merge response - fix up 1st*/
609 if (coalesce_t2(smb_buffer,
610 mid_entry->resp_buf)) {
611 mid_entry->multiRsp =
615 /* all parts received */
616 mid_entry->multiEnd =
622 cERROR(1, "1st trans2 resp needs bigbuf");
623 /* BB maybe we can fix this up, switch
624 to already allocated large buffer? */
626 /* Have first buffer */
627 mid_entry->resp_buf =
629 mid_entry->largeBuf =
636 mid_entry->resp_buf = smb_buffer;
637 mid_entry->largeBuf = isLargeBuf;
639 mid_entry->midState = MID_RESPONSE_RECEIVED;
640 #ifdef CONFIG_CIFS_STATS2
641 mid_entry->when_received = jiffies;
643 list_del_init(&mid_entry->qhead);
644 mid_entry->callback(mid_entry);
649 spin_unlock(&GlobalMid_Lock);
651 if (mid_entry != NULL) {
652 /* Was previous buf put in mpx struct for multi-rsp? */
654 /* smb buffer will be freed by user thread */
660 } else if (!is_valid_oplock_break(smb_buffer, server) &&
662 cERROR(1, "No task to wake, unknown frame received! "
663 "NumMids %d", atomic_read(&midCount));
664 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
665 sizeof(struct smb_hdr));
666 #ifdef CONFIG_CIFS_DEBUG2
667 cifs_dump_detail(smb_buffer);
668 cifs_dump_mids(server);
669 #endif /* CIFS_DEBUG2 */
672 } /* end while !EXITING */
674 /* take it off the list, if it's not already */
675 spin_lock(&cifs_tcp_ses_lock);
676 list_del_init(&server->tcp_ses_list);
677 spin_unlock(&cifs_tcp_ses_lock);
679 spin_lock(&GlobalMid_Lock);
680 server->tcpStatus = CifsExiting;
681 spin_unlock(&GlobalMid_Lock);
682 wake_up_all(&server->response_q);
684 /* check if we have blocked requests that need to free */
685 /* Note that cifs_max_pending is normally 50, but
686 can be set at module install time to as little as two */
687 spin_lock(&GlobalMid_Lock);
688 if (atomic_read(&server->inFlight) >= cifs_max_pending)
689 atomic_set(&server->inFlight, cifs_max_pending - 1);
690 /* We do not want to set the max_pending too low or we
691 could end up with the counter going negative */
692 spin_unlock(&GlobalMid_Lock);
693 /* Although there should not be any requests blocked on
694 this queue it can not hurt to be paranoid and try to wake up requests
695 that may haven been blocked when more than 50 at time were on the wire
696 to the same server - they now will see the session is in exit state
697 and get out of SendReceive. */
698 wake_up_all(&server->request_q);
699 /* give those requests time to exit */
702 if (server->ssocket) {
703 sock_release(csocket);
704 server->ssocket = NULL;
706 /* buffer usuallly freed in free_mid - need to free it here on exit */
707 cifs_buf_release(bigbuf);
708 if (smallbuf) /* no sense logging a debug message if NULL */
709 cifs_small_buf_release(smallbuf);
711 if (!list_empty(&server->pending_mid_q)) {
712 spin_lock(&GlobalMid_Lock);
713 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
714 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
715 cFYI(1, "Clearing Mid 0x%x - issuing callback",
717 list_del_init(&mid_entry->qhead);
718 mid_entry->callback(mid_entry);
720 spin_unlock(&GlobalMid_Lock);
721 /* 1/8th of sec is more than enough time for them to exit */
725 if (!list_empty(&server->pending_mid_q)) {
726 /* mpx threads have not exited yet give them
727 at least the smb send timeout time for long ops */
728 /* due to delays on oplock break requests, we need
729 to wait at least 45 seconds before giving up
730 on a request getting a response and going ahead
732 cFYI(1, "Wait for exit from demultiplex thread");
734 /* if threads still have not exited they are probably never
735 coming home not much else we can do but free the memory */
738 kfree(server->hostname);
739 task_to_wake = xchg(&server->tsk, NULL);
742 length = atomic_dec_return(&tcpSesAllocCount);
744 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
747 /* if server->tsk was NULL then wait for a signal before exiting */
749 set_current_state(TASK_INTERRUPTIBLE);
750 while (!signal_pending(current)) {
752 set_current_state(TASK_INTERRUPTIBLE);
754 set_current_state(TASK_RUNNING);
757 module_put_and_exit(0);
760 /* extract the host portion of the UNC string */
762 extract_hostname(const char *unc)
768 /* skip double chars at beginning of string */
769 /* BB: check validity of these bytes? */
772 /* delimiter between hostname and sharename is always '\\' now */
773 delim = strchr(src, '\\');
775 return ERR_PTR(-EINVAL);
778 dst = kmalloc((len + 1), GFP_KERNEL);
780 return ERR_PTR(-ENOMEM);
782 memcpy(dst, src, len);
789 cifs_parse_mount_options(char *options, const char *devname,
794 unsigned int temp_len, i, j;
796 short int override_uid = -1;
797 short int override_gid = -1;
798 bool uid_specified = false;
799 bool gid_specified = false;
800 char *nodename = utsname()->nodename;
806 * does not have to be perfect mapping since field is
807 * informational, only used for servers that do not support
808 * port 445 and it can be overridden at mount time
810 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
811 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
812 vol->source_rfc1001_name[i] = toupper(nodename[i]);
814 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
815 /* null target name indicates to use *SMBSERVR default called name
816 if we end up sending RFC1001 session initialize */
817 vol->target_rfc1001_name[0] = 0;
818 vol->cred_uid = current_uid();
819 vol->linux_uid = current_uid();
820 vol->linux_gid = current_gid();
822 /* default to only allowing write access to owner of the mount */
823 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
825 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
826 /* default is always to request posix paths. */
827 vol->posix_paths = 1;
828 /* default to using server inode numbers where available */
831 vol->actimeo = CIFS_DEF_ACTIMEO;
836 if (strncmp(options, "sep=", 4) == 0) {
837 if (options[4] != 0) {
838 separator[0] = options[4];
841 cFYI(1, "Null separator not allowed");
845 while ((data = strsep(&options, separator)) != NULL) {
848 if ((value = strchr(data, '=')) != NULL)
851 /* Have to parse this before we parse for "user" */
852 if (strnicmp(data, "user_xattr", 10) == 0) {
854 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
856 } else if (strnicmp(data, "user", 4) == 0) {
859 "CIFS: invalid or missing username\n");
860 return 1; /* needs_arg; */
861 } else if (!*value) {
862 /* null user, ie anonymous, authentication */
865 if (strnlen(value, 200) < 200) {
866 vol->username = value;
868 printk(KERN_WARNING "CIFS: username too long\n");
871 } else if (strnicmp(data, "pass", 4) == 0) {
873 vol->password = NULL;
875 } else if (value[0] == 0) {
876 /* check if string begins with double comma
877 since that would mean the password really
878 does start with a comma, and would not
879 indicate an empty string */
880 if (value[1] != separator[0]) {
881 vol->password = NULL;
885 temp_len = strlen(value);
886 /* removed password length check, NTLM passwords
887 can be arbitrarily long */
889 /* if comma in password, the string will be
890 prematurely null terminated. Commas in password are
891 specified across the cifs mount interface by a double
892 comma ie ,, and a comma used as in other cases ie ','
893 as a parameter delimiter/separator is single and due
894 to the strsep above is temporarily zeroed. */
896 /* NB: password legally can have multiple commas and
897 the only illegal character in a password is null */
899 if ((value[temp_len] == 0) &&
900 (value[temp_len+1] == separator[0])) {
902 value[temp_len] = separator[0];
903 temp_len += 2; /* move after second comma */
904 while (value[temp_len] != 0) {
905 if (value[temp_len] == separator[0]) {
906 if (value[temp_len+1] ==
908 /* skip second comma */
911 /* single comma indicating start
918 if (value[temp_len] == 0) {
922 /* point option to start of next parm */
923 options = value + temp_len + 1;
925 /* go from value to value + temp_len condensing
926 double commas to singles. Note that this ends up
927 allocating a few bytes too many, which is ok */
928 vol->password = kzalloc(temp_len, GFP_KERNEL);
929 if (vol->password == NULL) {
930 printk(KERN_WARNING "CIFS: no memory "
934 for (i = 0, j = 0; i < temp_len; i++, j++) {
935 vol->password[j] = value[i];
936 if (value[i] == separator[0]
937 && value[i+1] == separator[0]) {
938 /* skip second comma */
942 vol->password[j] = 0;
944 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
945 if (vol->password == NULL) {
946 printk(KERN_WARNING "CIFS: no memory "
950 strcpy(vol->password, value);
952 } else if (!strnicmp(data, "ip", 2) ||
953 !strnicmp(data, "addr", 4)) {
954 if (!value || !*value) {
956 } else if (strnlen(value, INET6_ADDRSTRLEN) <
960 printk(KERN_WARNING "CIFS: ip address "
964 } else if (strnicmp(data, "sec", 3) == 0) {
965 if (!value || !*value) {
966 cERROR(1, "no security value specified");
968 } else if (strnicmp(value, "krb5i", 5) == 0) {
969 vol->secFlg |= CIFSSEC_MAY_KRB5 |
971 } else if (strnicmp(value, "krb5p", 5) == 0) {
972 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
974 cERROR(1, "Krb5 cifs privacy not supported");
976 } else if (strnicmp(value, "krb5", 4) == 0) {
977 vol->secFlg |= CIFSSEC_MAY_KRB5;
978 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
979 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
981 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
982 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
983 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
984 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
986 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
987 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
988 } else if (strnicmp(value, "ntlmi", 5) == 0) {
989 vol->secFlg |= CIFSSEC_MAY_NTLM |
991 } else if (strnicmp(value, "ntlm", 4) == 0) {
992 /* ntlm is default so can be turned off too */
993 vol->secFlg |= CIFSSEC_MAY_NTLM;
994 } else if (strnicmp(value, "nontlm", 6) == 0) {
995 /* BB is there a better way to do this? */
996 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
997 #ifdef CONFIG_CIFS_WEAK_PW_HASH
998 } else if (strnicmp(value, "lanman", 6) == 0) {
999 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1001 } else if (strnicmp(value, "none", 4) == 0) {
1004 cERROR(1, "bad security option: %s", value);
1007 } else if ((strnicmp(data, "unc", 3) == 0)
1008 || (strnicmp(data, "target", 6) == 0)
1009 || (strnicmp(data, "path", 4) == 0)) {
1010 if (!value || !*value) {
1011 printk(KERN_WARNING "CIFS: invalid path to "
1012 "network resource\n");
1013 return 1; /* needs_arg; */
1015 if ((temp_len = strnlen(value, 300)) < 300) {
1016 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1017 if (vol->UNC == NULL)
1019 strcpy(vol->UNC, value);
1020 if (strncmp(vol->UNC, "//", 2) == 0) {
1023 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1025 "CIFS: UNC Path does not begin "
1026 "with // or \\\\ \n");
1030 printk(KERN_WARNING "CIFS: UNC name too long\n");
1033 } else if ((strnicmp(data, "domain", 3) == 0)
1034 || (strnicmp(data, "workgroup", 5) == 0)) {
1035 if (!value || !*value) {
1036 printk(KERN_WARNING "CIFS: invalid domain name\n");
1037 return 1; /* needs_arg; */
1039 /* BB are there cases in which a comma can be valid in
1040 a domain name and need special handling? */
1041 if (strnlen(value, 256) < 256) {
1042 vol->domainname = value;
1043 cFYI(1, "Domain name set");
1045 printk(KERN_WARNING "CIFS: domain name too "
1049 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1050 vol->srcaddr.ss_family = AF_UNSPEC;
1052 if (!value || !*value) {
1053 printk(KERN_WARNING "CIFS: srcaddr value"
1054 " not specified.\n");
1055 return 1; /* needs_arg; */
1057 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1058 value, strlen(value));
1060 printk(KERN_WARNING "CIFS: Could not parse"
1065 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1066 if (!value || !*value) {
1068 "CIFS: invalid path prefix\n");
1069 return 1; /* needs_argument */
1071 if ((temp_len = strnlen(value, 1024)) < 1024) {
1072 if (value[0] != '/')
1073 temp_len++; /* missing leading slash */
1074 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1075 if (vol->prepath == NULL)
1077 if (value[0] != '/') {
1078 vol->prepath[0] = '/';
1079 strcpy(vol->prepath+1, value);
1081 strcpy(vol->prepath, value);
1082 cFYI(1, "prefix path %s", vol->prepath);
1084 printk(KERN_WARNING "CIFS: prefix too long\n");
1087 } else if (strnicmp(data, "iocharset", 9) == 0) {
1088 if (!value || !*value) {
1089 printk(KERN_WARNING "CIFS: invalid iocharset "
1091 return 1; /* needs_arg; */
1093 if (strnlen(value, 65) < 65) {
1094 if (strnicmp(value, "default", 7))
1095 vol->iocharset = value;
1096 /* if iocharset not set then load_nls_default
1097 is used by caller */
1098 cFYI(1, "iocharset set to %s", value);
1100 printk(KERN_WARNING "CIFS: iocharset name "
1104 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1105 vol->linux_uid = simple_strtoul(value, &value, 0);
1106 uid_specified = true;
1107 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1108 vol->cred_uid = simple_strtoul(value, &value, 0);
1109 } else if (!strnicmp(data, "forceuid", 8)) {
1111 } else if (!strnicmp(data, "noforceuid", 10)) {
1113 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1114 vol->linux_gid = simple_strtoul(value, &value, 0);
1115 gid_specified = true;
1116 } else if (!strnicmp(data, "forcegid", 8)) {
1118 } else if (!strnicmp(data, "noforcegid", 10)) {
1120 } else if (strnicmp(data, "file_mode", 4) == 0) {
1121 if (value && *value) {
1123 simple_strtoul(value, &value, 0);
1125 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1126 if (value && *value) {
1128 simple_strtoul(value, &value, 0);
1130 } else if (strnicmp(data, "dirmode", 4) == 0) {
1131 if (value && *value) {
1133 simple_strtoul(value, &value, 0);
1135 } else if (strnicmp(data, "port", 4) == 0) {
1136 if (value && *value) {
1138 simple_strtoul(value, &value, 0);
1140 } else if (strnicmp(data, "rsize", 5) == 0) {
1141 if (value && *value) {
1143 simple_strtoul(value, &value, 0);
1145 } else if (strnicmp(data, "wsize", 5) == 0) {
1146 if (value && *value) {
1148 simple_strtoul(value, &value, 0);
1150 } else if (strnicmp(data, "sockopt", 5) == 0) {
1151 if (!value || !*value) {
1152 cERROR(1, "no socket option specified");
1154 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1155 vol->sockopt_tcp_nodelay = 1;
1157 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1158 if (!value || !*value || (*value == ' ')) {
1159 cFYI(1, "invalid (empty) netbiosname");
1161 memset(vol->source_rfc1001_name, 0x20,
1164 * FIXME: are there cases in which a comma can
1165 * be valid in workstation netbios name (and
1166 * need special handling)?
1168 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1169 /* don't ucase netbiosname for user */
1172 vol->source_rfc1001_name[i] = value[i];
1174 /* The string has 16th byte zero still from
1175 set at top of the function */
1176 if (i == RFC1001_NAME_LEN && value[i] != 0)
1177 printk(KERN_WARNING "CIFS: netbiosname"
1178 " longer than 15 truncated.\n");
1180 } else if (strnicmp(data, "servern", 7) == 0) {
1181 /* servernetbiosname specified override *SMBSERVER */
1182 if (!value || !*value || (*value == ' ')) {
1183 cFYI(1, "empty server netbiosname specified");
1185 /* last byte, type, is 0x20 for servr type */
1186 memset(vol->target_rfc1001_name, 0x20,
1187 RFC1001_NAME_LEN_WITH_NULL);
1189 for (i = 0; i < 15; i++) {
1190 /* BB are there cases in which a comma can be
1191 valid in this workstation netbios name
1192 (and need special handling)? */
1194 /* user or mount helper must uppercase
1199 vol->target_rfc1001_name[i] =
1202 /* The string has 16th byte zero still from
1203 set at top of the function */
1204 if (i == RFC1001_NAME_LEN && value[i] != 0)
1205 printk(KERN_WARNING "CIFS: server net"
1206 "biosname longer than 15 truncated.\n");
1208 } else if (strnicmp(data, "actimeo", 7) == 0) {
1209 if (value && *value) {
1210 vol->actimeo = HZ * simple_strtoul(value,
1212 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1213 cERROR(1, "CIFS: attribute cache"
1214 "timeout too large");
1218 } else if (strnicmp(data, "credentials", 4) == 0) {
1220 } else if (strnicmp(data, "version", 3) == 0) {
1222 } else if (strnicmp(data, "guest", 5) == 0) {
1224 } else if (strnicmp(data, "rw", 2) == 0) {
1226 } else if (strnicmp(data, "ro", 2) == 0) {
1228 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1229 vol->noblocksnd = 1;
1230 } else if (strnicmp(data, "noautotune", 10) == 0) {
1231 vol->noautotune = 1;
1232 } else if ((strnicmp(data, "suid", 4) == 0) ||
1233 (strnicmp(data, "nosuid", 6) == 0) ||
1234 (strnicmp(data, "exec", 4) == 0) ||
1235 (strnicmp(data, "noexec", 6) == 0) ||
1236 (strnicmp(data, "nodev", 5) == 0) ||
1237 (strnicmp(data, "noauto", 6) == 0) ||
1238 (strnicmp(data, "dev", 3) == 0)) {
1239 /* The mount tool or mount.cifs helper (if present)
1240 uses these opts to set flags, and the flags are read
1241 by the kernel vfs layer before we get here (ie
1242 before read super) so there is no point trying to
1243 parse these options again and set anything and it
1244 is ok to just ignore them */
1246 } else if (strnicmp(data, "hard", 4) == 0) {
1248 } else if (strnicmp(data, "soft", 4) == 0) {
1250 } else if (strnicmp(data, "perm", 4) == 0) {
1252 } else if (strnicmp(data, "noperm", 6) == 0) {
1254 } else if (strnicmp(data, "mapchars", 8) == 0) {
1256 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1258 } else if (strnicmp(data, "sfu", 3) == 0) {
1260 } else if (strnicmp(data, "nosfu", 5) == 0) {
1262 } else if (strnicmp(data, "nodfs", 5) == 0) {
1264 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1265 vol->posix_paths = 1;
1266 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1267 vol->posix_paths = 0;
1268 } else if (strnicmp(data, "nounix", 6) == 0) {
1269 vol->no_linux_ext = 1;
1270 } else if (strnicmp(data, "nolinux", 7) == 0) {
1271 vol->no_linux_ext = 1;
1272 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1273 (strnicmp(data, "ignorecase", 10) == 0)) {
1275 } else if (strnicmp(data, "mand", 4) == 0) {
1277 } else if (strnicmp(data, "nomand", 6) == 0) {
1279 } else if (strnicmp(data, "_netdev", 7) == 0) {
1281 } else if (strnicmp(data, "brl", 3) == 0) {
1283 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1284 (strnicmp(data, "nolock", 6) == 0)) {
1286 /* turn off mandatory locking in mode
1287 if remote locking is turned off since the
1288 local vfs will do advisory */
1289 if (vol->file_mode ==
1290 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1291 vol->file_mode = S_IALLUGO;
1292 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1293 /* will take the shorter form "forcemand" as well */
1294 /* This mount option will force use of mandatory
1295 (DOS/Windows style) byte range locks, instead of
1296 using posix advisory byte range locks, even if the
1297 Unix extensions are available and posix locks would
1298 be supported otherwise. If Unix extensions are not
1299 negotiated this has no effect since mandatory locks
1300 would be used (mandatory locks is all that those
1301 those servers support) */
1303 } else if (strnicmp(data, "setuids", 7) == 0) {
1305 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1307 } else if (strnicmp(data, "dynperm", 7) == 0) {
1308 vol->dynperm = true;
1309 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1310 vol->dynperm = false;
1311 } else if (strnicmp(data, "nohard", 6) == 0) {
1313 } else if (strnicmp(data, "nosoft", 6) == 0) {
1315 } else if (strnicmp(data, "nointr", 6) == 0) {
1317 } else if (strnicmp(data, "intr", 4) == 0) {
1319 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1320 vol->nostrictsync = 1;
1321 } else if (strnicmp(data, "strictsync", 10) == 0) {
1322 vol->nostrictsync = 0;
1323 } else if (strnicmp(data, "serverino", 7) == 0) {
1324 vol->server_ino = 1;
1325 } else if (strnicmp(data, "noserverino", 9) == 0) {
1326 vol->server_ino = 0;
1327 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1329 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1331 } else if (strnicmp(data, "acl", 3) == 0) {
1332 vol->no_psx_acl = 0;
1333 } else if (strnicmp(data, "noacl", 5) == 0) {
1334 vol->no_psx_acl = 1;
1335 } else if (strnicmp(data, "locallease", 6) == 0) {
1336 vol->local_lease = 1;
1337 } else if (strnicmp(data, "sign", 4) == 0) {
1338 vol->secFlg |= CIFSSEC_MUST_SIGN;
1339 } else if (strnicmp(data, "seal", 4) == 0) {
1340 /* we do not do the following in secFlags because seal
1341 is a per tree connection (mount) not a per socket
1342 or per-smb connection option in the protocol */
1343 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1345 } else if (strnicmp(data, "direct", 6) == 0) {
1347 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1349 } else if (strnicmp(data, "strictcache", 11) == 0) {
1351 } else if (strnicmp(data, "noac", 4) == 0) {
1352 printk(KERN_WARNING "CIFS: Mount option noac not "
1353 "supported. Instead set "
1354 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1355 } else if (strnicmp(data, "fsc", 3) == 0) {
1356 #ifndef CONFIG_CIFS_FSCACHE
1357 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1358 "kernel config option set");
1362 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1363 vol->mfsymlinks = true;
1364 } else if (strnicmp(data, "multiuser", 8) == 0) {
1365 vol->multiuser = true;
1367 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1370 if (vol->UNC == NULL) {
1371 if (devname == NULL) {
1372 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1376 if ((temp_len = strnlen(devname, 300)) < 300) {
1377 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1378 if (vol->UNC == NULL)
1380 strcpy(vol->UNC, devname);
1381 if (strncmp(vol->UNC, "//", 2) == 0) {
1384 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1385 printk(KERN_WARNING "CIFS: UNC Path does not "
1386 "begin with // or \\\\ \n");
1389 value = strpbrk(vol->UNC+2, "/\\");
1393 printk(KERN_WARNING "CIFS: UNC name too long\n");
1398 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1399 cERROR(1, "Multiuser mounts currently require krb5 "
1404 if (vol->UNCip == NULL)
1405 vol->UNCip = &vol->UNC[2];
1408 vol->override_uid = override_uid;
1409 else if (override_uid == 1)
1410 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1411 "specified with no uid= option.\n");
1414 vol->override_gid = override_gid;
1415 else if (override_gid == 1)
1416 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1417 "specified with no gid= option.\n");
1422 /** Returns true if srcaddr isn't specified and rhs isn't
1423 * specified, or if srcaddr is specified and
1424 * matches the IP address of the rhs argument.
1427 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1429 switch (srcaddr->sa_family) {
1431 return (rhs->sa_family == AF_UNSPEC);
1433 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1434 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1435 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1438 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1439 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1440 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1444 return false; /* don't expect to be here */
1449 * If no port is specified in addr structure, we try to match with 445 port
1450 * and if it fails - with 139 ports. It should be called only if address
1451 * families of server and addr are equal.
1454 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1456 unsigned short int port, *sport;
1458 switch (addr->sa_family) {
1460 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1461 port = ((struct sockaddr_in *) addr)->sin_port;
1464 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1465 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1473 port = htons(CIFS_PORT);
1477 port = htons(RFC1001_PORT);
1480 return port == *sport;
1484 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1485 struct sockaddr *srcaddr)
1487 switch (addr->sa_family) {
1489 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1490 struct sockaddr_in *srv_addr4 =
1491 (struct sockaddr_in *)&server->dstaddr;
1493 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1498 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1499 struct sockaddr_in6 *srv_addr6 =
1500 (struct sockaddr_in6 *)&server->dstaddr;
1502 if (!ipv6_addr_equal(&addr6->sin6_addr,
1503 &srv_addr6->sin6_addr))
1505 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1511 return false; /* don't expect to be here */
1514 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1521 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1523 unsigned int secFlags;
1525 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1526 secFlags = vol->secFlg;
1528 secFlags = global_secflags | vol->secFlg;
1530 switch (server->secType) {
1532 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1536 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1540 if (!(secFlags & CIFSSEC_MAY_NTLM))
1544 if (!(secFlags & CIFSSEC_MAY_KRB5))
1548 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1552 /* shouldn't happen */
1556 /* now check if signing mode is acceptible */
1557 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1558 (server->secMode & SECMODE_SIGN_REQUIRED))
1560 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1562 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1568 static struct TCP_Server_Info *
1569 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1571 struct TCP_Server_Info *server;
1573 spin_lock(&cifs_tcp_ses_lock);
1574 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1575 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1578 if (!match_address(server, addr,
1579 (struct sockaddr *)&vol->srcaddr))
1582 if (!match_port(server, addr))
1585 if (!match_security(server, vol))
1588 ++server->srv_count;
1589 spin_unlock(&cifs_tcp_ses_lock);
1590 cFYI(1, "Existing tcp session with server found");
1593 spin_unlock(&cifs_tcp_ses_lock);
1598 cifs_put_tcp_session(struct TCP_Server_Info *server)
1600 struct task_struct *task;
1602 spin_lock(&cifs_tcp_ses_lock);
1603 if (--server->srv_count > 0) {
1604 spin_unlock(&cifs_tcp_ses_lock);
1608 put_net(cifs_net_ns(server));
1610 list_del_init(&server->tcp_ses_list);
1611 spin_unlock(&cifs_tcp_ses_lock);
1613 cancel_delayed_work_sync(&server->echo);
1615 spin_lock(&GlobalMid_Lock);
1616 server->tcpStatus = CifsExiting;
1617 spin_unlock(&GlobalMid_Lock);
1619 cifs_crypto_shash_release(server);
1620 cifs_fscache_release_client_cookie(server);
1622 kfree(server->session_key.response);
1623 server->session_key.response = NULL;
1624 server->session_key.len = 0;
1626 task = xchg(&server->tsk, NULL);
1628 force_sig(SIGKILL, task);
1631 static struct TCP_Server_Info *
1632 cifs_get_tcp_session(struct smb_vol *volume_info)
1634 struct TCP_Server_Info *tcp_ses = NULL;
1635 struct sockaddr_storage addr;
1636 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1637 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1640 memset(&addr, 0, sizeof(struct sockaddr_storage));
1642 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1644 if (volume_info->UNCip && volume_info->UNC) {
1645 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1647 strlen(volume_info->UNCip),
1650 /* we failed translating address */
1654 } else if (volume_info->UNCip) {
1655 /* BB using ip addr as tcp_ses name to connect to the
1657 cERROR(1, "Connecting to DFS root not implemented yet");
1660 } else /* which tcp_sess DFS root would we conect to */ {
1661 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1662 "unc=//192.168.1.100/public) specified");
1667 /* see if we already have a matching tcp_ses */
1668 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1672 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1678 rc = cifs_crypto_shash_allocate(tcp_ses);
1680 cERROR(1, "could not setup hash structures rc %d", rc);
1684 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1685 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1686 if (IS_ERR(tcp_ses->hostname)) {
1687 rc = PTR_ERR(tcp_ses->hostname);
1688 goto out_err_crypto_release;
1691 tcp_ses->noblocksnd = volume_info->noblocksnd;
1692 tcp_ses->noautotune = volume_info->noautotune;
1693 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1694 atomic_set(&tcp_ses->inFlight, 0);
1695 init_waitqueue_head(&tcp_ses->response_q);
1696 init_waitqueue_head(&tcp_ses->request_q);
1697 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1698 mutex_init(&tcp_ses->srv_mutex);
1699 memcpy(tcp_ses->workstation_RFC1001_name,
1700 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1701 memcpy(tcp_ses->server_RFC1001_name,
1702 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1703 tcp_ses->session_estab = false;
1704 tcp_ses->sequence_number = 0;
1705 tcp_ses->lstrp = jiffies;
1706 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1707 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1708 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1711 * at this point we are the only ones with the pointer
1712 * to the struct since the kernel thread not created yet
1713 * no need to spinlock this init of tcpStatus or srv_count
1715 tcp_ses->tcpStatus = CifsNew;
1716 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1717 sizeof(tcp_ses->srcaddr));
1718 ++tcp_ses->srv_count;
1720 if (addr.ss_family == AF_INET6) {
1721 cFYI(1, "attempting ipv6 connect");
1722 /* BB should we allow ipv6 on port 139? */
1723 /* other OS never observed in Wild doing 139 with v6 */
1724 memcpy(&tcp_ses->dstaddr, sin_server6,
1725 sizeof(struct sockaddr_in6));
1727 memcpy(&tcp_ses->dstaddr, sin_server,
1728 sizeof(struct sockaddr_in));
1730 rc = ip_connect(tcp_ses);
1732 cERROR(1, "Error connecting to socket. Aborting operation");
1733 goto out_err_crypto_release;
1737 * since we're in a cifs function already, we know that
1738 * this will succeed. No need for try_module_get().
1740 __module_get(THIS_MODULE);
1741 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1743 if (IS_ERR(tcp_ses->tsk)) {
1744 rc = PTR_ERR(tcp_ses->tsk);
1745 cERROR(1, "error %d create cifsd thread", rc);
1746 module_put(THIS_MODULE);
1747 goto out_err_crypto_release;
1750 /* thread spawned, put it on the list */
1751 spin_lock(&cifs_tcp_ses_lock);
1752 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1753 spin_unlock(&cifs_tcp_ses_lock);
1755 cifs_fscache_get_client_cookie(tcp_ses);
1757 /* queue echo request delayed work */
1758 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1762 out_err_crypto_release:
1763 cifs_crypto_shash_release(tcp_ses);
1765 put_net(cifs_net_ns(tcp_ses));
1769 if (!IS_ERR(tcp_ses->hostname))
1770 kfree(tcp_ses->hostname);
1771 if (tcp_ses->ssocket)
1772 sock_release(tcp_ses->ssocket);
1778 static struct cifsSesInfo *
1779 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1781 struct cifsSesInfo *ses;
1783 spin_lock(&cifs_tcp_ses_lock);
1784 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1785 switch (server->secType) {
1787 if (vol->cred_uid != ses->cred_uid)
1791 /* anything else takes username/password */
1792 if (strncmp(ses->userName, vol->username,
1795 if (strlen(vol->username) != 0 &&
1796 ses->password != NULL &&
1797 strncmp(ses->password,
1798 vol->password ? vol->password : "",
1803 spin_unlock(&cifs_tcp_ses_lock);
1806 spin_unlock(&cifs_tcp_ses_lock);
1811 cifs_put_smb_ses(struct cifsSesInfo *ses)
1814 struct TCP_Server_Info *server = ses->server;
1816 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1817 spin_lock(&cifs_tcp_ses_lock);
1818 if (--ses->ses_count > 0) {
1819 spin_unlock(&cifs_tcp_ses_lock);
1823 list_del_init(&ses->smb_ses_list);
1824 spin_unlock(&cifs_tcp_ses_lock);
1826 if (ses->status == CifsGood) {
1828 CIFSSMBLogoff(xid, ses);
1832 cifs_put_tcp_session(server);
1835 static struct cifsSesInfo *
1836 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1838 int rc = -ENOMEM, xid;
1839 struct cifsSesInfo *ses;
1840 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1841 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1845 ses = cifs_find_smb_ses(server, volume_info);
1847 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1849 mutex_lock(&ses->session_mutex);
1850 rc = cifs_negotiate_protocol(xid, ses);
1852 mutex_unlock(&ses->session_mutex);
1853 /* problem -- put our ses reference */
1854 cifs_put_smb_ses(ses);
1858 if (ses->need_reconnect) {
1859 cFYI(1, "Session needs reconnect");
1860 rc = cifs_setup_session(xid, ses,
1861 volume_info->local_nls);
1863 mutex_unlock(&ses->session_mutex);
1864 /* problem -- put our reference */
1865 cifs_put_smb_ses(ses);
1870 mutex_unlock(&ses->session_mutex);
1872 /* existing SMB ses has a server reference already */
1873 cifs_put_tcp_session(server);
1878 cFYI(1, "Existing smb sess not found");
1879 ses = sesInfoAlloc();
1883 /* new SMB session uses our server ref */
1884 ses->server = server;
1885 if (server->dstaddr.ss_family == AF_INET6)
1886 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1888 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1890 if (volume_info->username)
1891 strncpy(ses->userName, volume_info->username,
1894 /* volume_info->password freed at unmount */
1895 if (volume_info->password) {
1896 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1900 if (volume_info->domainname) {
1901 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1902 if (!ses->domainName)
1905 ses->cred_uid = volume_info->cred_uid;
1906 ses->linux_uid = volume_info->linux_uid;
1907 ses->overrideSecFlg = volume_info->secFlg;
1909 mutex_lock(&ses->session_mutex);
1910 rc = cifs_negotiate_protocol(xid, ses);
1912 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1913 mutex_unlock(&ses->session_mutex);
1917 /* success, put it on the list */
1918 spin_lock(&cifs_tcp_ses_lock);
1919 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1920 spin_unlock(&cifs_tcp_ses_lock);
1931 static struct cifsTconInfo *
1932 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1934 struct list_head *tmp;
1935 struct cifsTconInfo *tcon;
1937 spin_lock(&cifs_tcp_ses_lock);
1938 list_for_each(tmp, &ses->tcon_list) {
1939 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1940 if (tcon->tidStatus == CifsExiting)
1942 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1946 spin_unlock(&cifs_tcp_ses_lock);
1949 spin_unlock(&cifs_tcp_ses_lock);
1954 cifs_put_tcon(struct cifsTconInfo *tcon)
1957 struct cifsSesInfo *ses = tcon->ses;
1959 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1960 spin_lock(&cifs_tcp_ses_lock);
1961 if (--tcon->tc_count > 0) {
1962 spin_unlock(&cifs_tcp_ses_lock);
1966 list_del_init(&tcon->tcon_list);
1967 spin_unlock(&cifs_tcp_ses_lock);
1970 CIFSSMBTDis(xid, tcon);
1973 cifs_fscache_release_super_cookie(tcon);
1975 cifs_put_smb_ses(ses);
1978 static struct cifsTconInfo *
1979 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1982 struct cifsTconInfo *tcon;
1984 tcon = cifs_find_tcon(ses, volume_info->UNC);
1986 cFYI(1, "Found match on UNC path");
1987 /* existing tcon already has a reference */
1988 cifs_put_smb_ses(ses);
1989 if (tcon->seal != volume_info->seal)
1990 cERROR(1, "transport encryption setting "
1991 "conflicts with existing tid");
1995 tcon = tconInfoAlloc();
2002 if (volume_info->password) {
2003 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2004 if (!tcon->password) {
2010 if (strchr(volume_info->UNC + 3, '\\') == NULL
2011 && strchr(volume_info->UNC + 3, '/') == NULL) {
2012 cERROR(1, "Missing share name");
2017 /* BB Do we need to wrap session_mutex around
2018 * this TCon call and Unix SetFS as
2019 * we do on SessSetup and reconnect? */
2021 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2023 cFYI(1, "CIFS Tcon rc = %d", rc);
2027 if (volume_info->nodfs) {
2028 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2029 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2031 tcon->seal = volume_info->seal;
2032 /* we can have only one retry value for a connection
2033 to a share so for resources mounted more than once
2034 to the same server share the last value passed in
2035 for the retry flag is used */
2036 tcon->retry = volume_info->retry;
2037 tcon->nocase = volume_info->nocase;
2038 tcon->local_lease = volume_info->local_lease;
2040 spin_lock(&cifs_tcp_ses_lock);
2041 list_add(&tcon->tcon_list, &ses->tcon_list);
2042 spin_unlock(&cifs_tcp_ses_lock);
2044 cifs_fscache_get_super_cookie(tcon);
2054 cifs_put_tlink(struct tcon_link *tlink)
2056 if (!tlink || IS_ERR(tlink))
2059 if (!atomic_dec_and_test(&tlink->tl_count) ||
2060 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2061 tlink->tl_time = jiffies;
2065 if (!IS_ERR(tlink_tcon(tlink)))
2066 cifs_put_tcon(tlink_tcon(tlink));
2072 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2073 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2074 struct dfs_info3_param **preferrals, int remap)
2079 *pnum_referrals = 0;
2082 if (pSesInfo->ipc_tid == 0) {
2083 temp_unc = kmalloc(2 /* for slashes */ +
2084 strnlen(pSesInfo->serverName,
2085 SERVER_NAME_LEN_WITH_NULL * 2)
2086 + 1 + 4 /* slash IPC$ */ + 2,
2088 if (temp_unc == NULL)
2092 strcpy(temp_unc + 2, pSesInfo->serverName);
2093 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2094 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2095 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2099 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2100 pnum_referrals, nls_codepage, remap);
2101 /* BB map targetUNCs to dfs_info3 structures, here or
2102 in CIFSGetDFSRefer BB */
2107 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2108 static struct lock_class_key cifs_key[2];
2109 static struct lock_class_key cifs_slock_key[2];
2112 cifs_reclassify_socket4(struct socket *sock)
2114 struct sock *sk = sock->sk;
2115 BUG_ON(sock_owned_by_user(sk));
2116 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2117 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2121 cifs_reclassify_socket6(struct socket *sock)
2123 struct sock *sk = sock->sk;
2124 BUG_ON(sock_owned_by_user(sk));
2125 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2126 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2130 cifs_reclassify_socket4(struct socket *sock)
2135 cifs_reclassify_socket6(struct socket *sock)
2140 /* See RFC1001 section 14 on representation of Netbios names */
2141 static void rfc1002mangle(char *target, char *source, unsigned int length)
2145 for (i = 0, j = 0; i < (length); i++) {
2146 /* mask a nibble at a time and encode */
2147 target[j] = 'A' + (0x0F & (source[i] >> 4));
2148 target[j+1] = 'A' + (0x0F & source[i]);
2155 bind_socket(struct TCP_Server_Info *server)
2158 if (server->srcaddr.ss_family != AF_UNSPEC) {
2159 /* Bind to the specified local IP address */
2160 struct socket *socket = server->ssocket;
2161 rc = socket->ops->bind(socket,
2162 (struct sockaddr *) &server->srcaddr,
2163 sizeof(server->srcaddr));
2165 struct sockaddr_in *saddr4;
2166 struct sockaddr_in6 *saddr6;
2167 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2168 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2169 if (saddr6->sin6_family == AF_INET6)
2171 "Failed to bind to: %pI6c, error: %d\n",
2172 &saddr6->sin6_addr, rc);
2175 "Failed to bind to: %pI4, error: %d\n",
2176 &saddr4->sin_addr.s_addr, rc);
2183 ip_rfc1001_connect(struct TCP_Server_Info *server)
2187 * some servers require RFC1001 sessinit before sending
2188 * negprot - BB check reconnection in case where second
2189 * sessinit is sent but no second negprot
2191 struct rfc1002_session_packet *ses_init_buf;
2192 struct smb_hdr *smb_buf;
2193 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2196 ses_init_buf->trailer.session_req.called_len = 32;
2198 if (server->server_RFC1001_name &&
2199 server->server_RFC1001_name[0] != 0)
2200 rfc1002mangle(ses_init_buf->trailer.
2201 session_req.called_name,
2202 server->server_RFC1001_name,
2203 RFC1001_NAME_LEN_WITH_NULL);
2205 rfc1002mangle(ses_init_buf->trailer.
2206 session_req.called_name,
2207 DEFAULT_CIFS_CALLED_NAME,
2208 RFC1001_NAME_LEN_WITH_NULL);
2210 ses_init_buf->trailer.session_req.calling_len = 32;
2213 * calling name ends in null (byte 16) from old smb
2216 if (server->workstation_RFC1001_name &&
2217 server->workstation_RFC1001_name[0] != 0)
2218 rfc1002mangle(ses_init_buf->trailer.
2219 session_req.calling_name,
2220 server->workstation_RFC1001_name,
2221 RFC1001_NAME_LEN_WITH_NULL);
2223 rfc1002mangle(ses_init_buf->trailer.
2224 session_req.calling_name,
2226 RFC1001_NAME_LEN_WITH_NULL);
2228 ses_init_buf->trailer.session_req.scope1 = 0;
2229 ses_init_buf->trailer.session_req.scope2 = 0;
2230 smb_buf = (struct smb_hdr *)ses_init_buf;
2232 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2233 smb_buf->smb_buf_length = 0x81000044;
2234 rc = smb_send(server, smb_buf, 0x44);
2235 kfree(ses_init_buf);
2237 * RFC1001 layer in at least one server
2238 * requires very short break before negprot
2239 * presumably because not expecting negprot
2240 * to follow so fast. This is a simple
2241 * solution that works without
2242 * complicating the code and causes no
2243 * significant slowing down on mount
2246 usleep_range(1000, 2000);
2249 * else the negprot may still work without this
2250 * even though malloc failed
2257 generic_ip_connect(struct TCP_Server_Info *server)
2260 unsigned short int sport;
2262 struct socket *socket = server->ssocket;
2263 struct sockaddr *saddr;
2265 saddr = (struct sockaddr *) &server->dstaddr;
2267 if (server->dstaddr.ss_family == AF_INET6) {
2268 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2269 slen = sizeof(struct sockaddr_in6);
2272 sport = ((struct sockaddr_in *) saddr)->sin_port;
2273 slen = sizeof(struct sockaddr_in);
2277 if (socket == NULL) {
2278 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2279 IPPROTO_TCP, &socket, 1);
2281 cERROR(1, "Error %d creating socket", rc);
2282 server->ssocket = NULL;
2286 /* BB other socket options to set KEEPALIVE, NODELAY? */
2287 cFYI(1, "Socket created");
2288 server->ssocket = socket;
2289 socket->sk->sk_allocation = GFP_NOFS;
2290 if (sfamily == AF_INET6)
2291 cifs_reclassify_socket6(socket);
2293 cifs_reclassify_socket4(socket);
2296 rc = bind_socket(server);
2300 rc = socket->ops->connect(socket, saddr, slen, 0);
2302 cFYI(1, "Error %d connecting to server", rc);
2303 sock_release(socket);
2304 server->ssocket = NULL;
2309 * Eventually check for other socket options to change from
2310 * the default. sock_setsockopt not used because it expects
2313 socket->sk->sk_rcvtimeo = 7 * HZ;
2314 socket->sk->sk_sndtimeo = 5 * HZ;
2316 /* make the bufsizes depend on wsize/rsize and max requests */
2317 if (server->noautotune) {
2318 if (socket->sk->sk_sndbuf < (200 * 1024))
2319 socket->sk->sk_sndbuf = 200 * 1024;
2320 if (socket->sk->sk_rcvbuf < (140 * 1024))
2321 socket->sk->sk_rcvbuf = 140 * 1024;
2324 if (server->tcp_nodelay) {
2326 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2327 (char *)&val, sizeof(val));
2329 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2332 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2333 socket->sk->sk_sndbuf,
2334 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2336 if (sport == htons(RFC1001_PORT))
2337 rc = ip_rfc1001_connect(server);
2343 ip_connect(struct TCP_Server_Info *server)
2345 unsigned short int *sport;
2346 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2347 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2349 if (server->dstaddr.ss_family == AF_INET6)
2350 sport = &addr6->sin6_port;
2352 sport = &addr->sin_port;
2357 /* try with 445 port at first */
2358 *sport = htons(CIFS_PORT);
2360 rc = generic_ip_connect(server);
2364 /* if it failed, try with 139 port */
2365 *sport = htons(RFC1001_PORT);
2368 return generic_ip_connect(server);
2371 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2372 struct super_block *sb, struct smb_vol *vol_info)
2374 /* if we are reconnecting then should we check to see if
2375 * any requested capabilities changed locally e.g. via
2376 * remount but we can not do much about it here
2377 * if they have (even if we could detect it by the following)
2378 * Perhaps we could add a backpointer to array of sb from tcon
2379 * or if we change to make all sb to same share the same
2380 * sb as NFS - then we only have one backpointer to sb.
2381 * What if we wanted to mount the server share twice once with
2382 * and once without posixacls or posix paths? */
2383 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2385 if (vol_info && vol_info->no_linux_ext) {
2386 tcon->fsUnixInfo.Capability = 0;
2387 tcon->unix_ext = 0; /* Unix Extensions disabled */
2388 cFYI(1, "Linux protocol extensions disabled");
2390 } else if (vol_info)
2391 tcon->unix_ext = 1; /* Unix Extensions supported */
2393 if (tcon->unix_ext == 0) {
2394 cFYI(1, "Unix extensions disabled so not set on reconnect");
2398 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2399 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2401 /* check for reconnect case in which we do not
2402 want to change the mount behavior if we can avoid it */
2403 if (vol_info == NULL) {
2404 /* turn off POSIX ACL and PATHNAMES if not set
2405 originally at mount time */
2406 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2407 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2408 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2409 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2410 cERROR(1, "POSIXPATH support change");
2411 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2412 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2413 cERROR(1, "possible reconnect error");
2414 cERROR(1, "server disabled POSIX path support");
2418 cap &= CIFS_UNIX_CAP_MASK;
2419 if (vol_info && vol_info->no_psx_acl)
2420 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2421 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2422 cFYI(1, "negotiated posix acl support");
2424 sb->s_flags |= MS_POSIXACL;
2427 if (vol_info && vol_info->posix_paths == 0)
2428 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2429 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2430 cFYI(1, "negotiate posix pathnames");
2432 CIFS_SB(sb)->mnt_cifs_flags |=
2433 CIFS_MOUNT_POSIX_PATHS;
2436 /* We might be setting the path sep back to a different
2437 form if we are reconnecting and the server switched its
2438 posix path capability for this share */
2439 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2440 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2442 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2443 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2444 CIFS_SB(sb)->rsize = 127 * 1024;
2445 cFYI(DBG2, "larger reads not supported by srv");
2450 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2451 #ifdef CONFIG_CIFS_DEBUG2
2452 if (cap & CIFS_UNIX_FCNTL_CAP)
2453 cFYI(1, "FCNTL cap");
2454 if (cap & CIFS_UNIX_EXTATTR_CAP)
2455 cFYI(1, "EXTATTR cap");
2456 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2457 cFYI(1, "POSIX path cap");
2458 if (cap & CIFS_UNIX_XATTR_CAP)
2459 cFYI(1, "XATTR cap");
2460 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2461 cFYI(1, "POSIX ACL cap");
2462 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2463 cFYI(1, "very large read cap");
2464 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2465 cFYI(1, "very large write cap");
2466 #endif /* CIFS_DEBUG2 */
2467 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2468 if (vol_info == NULL) {
2469 cFYI(1, "resetting capabilities failed");
2471 cERROR(1, "Negotiating Unix capabilities "
2472 "with the server failed. Consider "
2473 "mounting with the Unix Extensions\n"
2474 "disabled, if problems are found, "
2475 "by specifying the nounix mount "
2483 convert_delimiter(char *path, char delim)
2496 for (i = 0; path[i] != '\0'; i++) {
2497 if (path[i] == old_delim)
2502 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2503 struct cifs_sb_info *cifs_sb)
2505 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2507 if (pvolume_info->rsize > CIFSMaxBufSize) {
2508 cERROR(1, "rsize %d too large, using MaxBufSize",
2509 pvolume_info->rsize);
2510 cifs_sb->rsize = CIFSMaxBufSize;
2511 } else if ((pvolume_info->rsize) &&
2512 (pvolume_info->rsize <= CIFSMaxBufSize))
2513 cifs_sb->rsize = pvolume_info->rsize;
2515 cifs_sb->rsize = CIFSMaxBufSize;
2517 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2518 cERROR(1, "wsize %d too large, using 4096 instead",
2519 pvolume_info->wsize);
2520 cifs_sb->wsize = 4096;
2521 } else if (pvolume_info->wsize)
2522 cifs_sb->wsize = pvolume_info->wsize;
2524 cifs_sb->wsize = min_t(const int,
2525 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2527 /* old default of CIFSMaxBufSize was too small now
2528 that SMB Write2 can send multiple pages in kvec.
2529 RFC1001 does not describe what happens when frame
2530 bigger than 128K is sent so use that as max in
2531 conjunction with 52K kvec constraint on arch with 4K
2534 if (cifs_sb->rsize < 2048) {
2535 cifs_sb->rsize = 2048;
2536 /* Windows ME may prefer this */
2537 cFYI(1, "readsize set to minimum: 2048");
2539 /* calculate prepath */
2540 cifs_sb->prepath = pvolume_info->prepath;
2541 if (cifs_sb->prepath) {
2542 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2543 /* we can not convert the / to \ in the path
2544 separators in the prefixpath yet because we do not
2545 know (until reset_cifs_unix_caps is called later)
2546 whether POSIX PATH CAP is available. We normalize
2547 the / to \ after reset_cifs_unix_caps is called */
2548 pvolume_info->prepath = NULL;
2550 cifs_sb->prepathlen = 0;
2551 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2552 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2553 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2554 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2555 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2556 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2558 cifs_sb->actimeo = pvolume_info->actimeo;
2560 if (pvolume_info->noperm)
2561 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2562 if (pvolume_info->setuids)
2563 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2564 if (pvolume_info->server_ino)
2565 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2566 if (pvolume_info->remap)
2567 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2568 if (pvolume_info->no_xattr)
2569 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2570 if (pvolume_info->sfu_emul)
2571 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2572 if (pvolume_info->nobrl)
2573 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2574 if (pvolume_info->nostrictsync)
2575 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2576 if (pvolume_info->mand_lock)
2577 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2578 if (pvolume_info->cifs_acl)
2579 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2580 if (pvolume_info->override_uid)
2581 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2582 if (pvolume_info->override_gid)
2583 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2584 if (pvolume_info->dynperm)
2585 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2586 if (pvolume_info->fsc)
2587 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2588 if (pvolume_info->multiuser)
2589 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2590 CIFS_MOUNT_NO_PERM);
2591 if (pvolume_info->strict_io)
2592 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2593 if (pvolume_info->direct_io) {
2594 cFYI(1, "mounting share using direct i/o");
2595 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2597 if (pvolume_info->mfsymlinks) {
2598 if (pvolume_info->sfu_emul) {
2599 cERROR(1, "mount option mfsymlinks ignored if sfu "
2600 "mount option is used");
2602 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2606 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2607 cERROR(1, "mount option dynperm ignored if cifsacl "
2608 "mount option supported");
2612 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2613 struct cifs_sb_info *cifs_sb, const char *full_path)
2616 FILE_ALL_INFO *pfile_info;
2618 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2619 if (pfile_info == NULL)
2622 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2623 0 /* not legacy */, cifs_sb->local_nls,
2624 cifs_sb->mnt_cifs_flags &
2625 CIFS_MOUNT_MAP_SPECIAL_CHR);
2631 cleanup_volume_info(struct smb_vol **pvolume_info)
2633 struct smb_vol *volume_info;
2635 if (!pvolume_info || !*pvolume_info)
2638 volume_info = *pvolume_info;
2639 kzfree(volume_info->password);
2640 kfree(volume_info->UNC);
2641 kfree(volume_info->prepath);
2643 *pvolume_info = NULL;
2647 #ifdef CONFIG_CIFS_DFS_UPCALL
2648 /* build_path_to_root returns full path to root when
2649 * we do not have an exiting connection (tcon) */
2651 build_unc_path_to_root(const struct smb_vol *volume_info,
2652 const struct cifs_sb_info *cifs_sb)
2656 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2657 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2658 if (full_path == NULL)
2659 return ERR_PTR(-ENOMEM);
2661 strncpy(full_path, volume_info->UNC, unc_len);
2662 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2664 for (i = 0; i < unc_len; i++) {
2665 if (full_path[i] == '\\')
2670 if (cifs_sb->prepathlen)
2671 strncpy(full_path + unc_len, cifs_sb->prepath,
2672 cifs_sb->prepathlen);
2674 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2680 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2681 char *mount_data_global, const char *devname)
2685 struct smb_vol *volume_info;
2686 struct cifsSesInfo *pSesInfo;
2687 struct cifsTconInfo *tcon;
2688 struct TCP_Server_Info *srvTcp;
2690 char *mount_data = mount_data_global;
2691 struct tcon_link *tlink;
2692 #ifdef CONFIG_CIFS_DFS_UPCALL
2693 struct dfs_info3_param *referrals = NULL;
2694 unsigned int num_referrals = 0;
2695 int referral_walks_count = 0;
2707 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2713 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2718 if (volume_info->nullauth) {
2719 cFYI(1, "null user");
2720 volume_info->username = "";
2721 } else if (volume_info->username) {
2722 /* BB fixme parse for domain name here */
2723 cFYI(1, "Username: %s", volume_info->username);
2725 cifserror("No username specified");
2726 /* In userspace mount helper we can get user name from alternate
2727 locations such as env variables and files on disk */
2732 /* this is needed for ASCII cp to Unicode converts */
2733 if (volume_info->iocharset == NULL) {
2734 /* load_nls_default cannot return null */
2735 volume_info->local_nls = load_nls_default();
2737 volume_info->local_nls = load_nls(volume_info->iocharset);
2738 if (volume_info->local_nls == NULL) {
2739 cERROR(1, "CIFS mount error: iocharset %s not found",
2740 volume_info->iocharset);
2745 cifs_sb->local_nls = volume_info->local_nls;
2747 /* get a reference to a tcp session */
2748 srvTcp = cifs_get_tcp_session(volume_info);
2749 if (IS_ERR(srvTcp)) {
2750 rc = PTR_ERR(srvTcp);
2754 /* get a reference to a SMB session */
2755 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2756 if (IS_ERR(pSesInfo)) {
2757 rc = PTR_ERR(pSesInfo);
2759 goto mount_fail_check;
2762 setup_cifs_sb(volume_info, cifs_sb);
2763 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2764 sb->s_maxbytes = MAX_LFS_FILESIZE;
2766 sb->s_maxbytes = MAX_NON_LFS;
2768 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2769 sb->s_time_gran = 100;
2771 /* search for existing tcon to this server share */
2772 tcon = cifs_get_tcon(pSesInfo, volume_info);
2776 goto remote_path_check;
2779 /* do not care if following two calls succeed - informational */
2781 CIFSSMBQFSDeviceInfo(xid, tcon);
2782 CIFSSMBQFSAttributeInfo(xid, tcon);
2785 /* tell server which Unix caps we support */
2786 if (tcon->ses->capabilities & CAP_UNIX)
2787 /* reset of caps checks mount to see if unix extensions
2788 disabled for just this mount */
2789 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2791 tcon->unix_ext = 0; /* server does not support them */
2793 /* convert forward to back slashes in prepath here if needed */
2794 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2795 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2797 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2798 cifs_sb->rsize = 1024 * 127;
2799 cFYI(DBG2, "no very large read support, rsize now 127K");
2801 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2802 cifs_sb->wsize = min(cifs_sb->wsize,
2803 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2804 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2805 cifs_sb->rsize = min(cifs_sb->rsize,
2806 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2809 /* check if a whole path (including prepath) is not remote */
2810 if (!rc && cifs_sb->prepathlen && tcon) {
2811 /* build_path_to_root works only when we have a valid tcon */
2812 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2813 if (full_path == NULL) {
2815 goto mount_fail_check;
2817 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2818 if (rc != 0 && rc != -EREMOTE) {
2820 goto mount_fail_check;
2825 /* get referral if needed */
2826 if (rc == -EREMOTE) {
2827 #ifdef CONFIG_CIFS_DFS_UPCALL
2828 if (referral_walks_count > MAX_NESTED_LINKS) {
2830 * BB: when we implement proper loop detection,
2831 * we will remove this check. But now we need it
2832 * to prevent an indefinite loop if 'DFS tree' is
2833 * misconfigured (i.e. has loops).
2836 goto mount_fail_check;
2838 /* convert forward to back slashes in prepath here if needed */
2839 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2840 convert_delimiter(cifs_sb->prepath,
2841 CIFS_DIR_SEP(cifs_sb));
2842 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2843 if (IS_ERR(full_path)) {
2844 rc = PTR_ERR(full_path);
2845 goto mount_fail_check;
2848 cFYI(1, "Getting referral for: %s", full_path);
2849 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2850 cifs_sb->local_nls, &num_referrals, &referrals,
2851 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2852 if (!rc && num_referrals > 0) {
2853 char *fake_devname = NULL;
2855 if (mount_data != mount_data_global)
2858 mount_data = cifs_compose_mount_options(
2859 cifs_sb->mountdata, full_path + 1,
2860 referrals, &fake_devname);
2862 free_dfs_info_array(referrals, num_referrals);
2863 kfree(fake_devname);
2866 if (IS_ERR(mount_data)) {
2867 rc = PTR_ERR(mount_data);
2869 goto mount_fail_check;
2873 cifs_put_tcon(tcon);
2875 cifs_put_smb_ses(pSesInfo);
2877 cleanup_volume_info(&volume_info);
2878 referral_walks_count++;
2880 goto try_mount_again;
2882 #else /* No DFS support, return error on mount */
2888 goto mount_fail_check;
2890 /* now, hang the tcon off of the superblock */
2891 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2892 if (tlink == NULL) {
2894 goto mount_fail_check;
2897 tlink->tl_uid = pSesInfo->linux_uid;
2898 tlink->tl_tcon = tcon;
2899 tlink->tl_time = jiffies;
2900 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2901 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2903 cifs_sb->master_tlink = tlink;
2904 spin_lock(&cifs_sb->tlink_tree_lock);
2905 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2906 spin_unlock(&cifs_sb->tlink_tree_lock);
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;
2950 __u16 bytes_left, count;
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_AUTH_RESP_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->server->cryptkey,
2989 ses->server->secMode &
2990 SECMODE_PW_ENCRYPT ? true : false,
2993 #endif /* CIFS_WEAK_PW_HASH */
2994 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
2997 bcc_ptr += CIFS_AUTH_RESP_SIZE;
2998 if (ses->capabilities & CAP_UNICODE) {
2999 /* must align unicode strings */
3000 *bcc_ptr = 0; /* null byte password */
3005 if (ses->server->secMode &
3006 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3007 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3009 if (ses->capabilities & CAP_STATUS32) {
3010 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3012 if (ses->capabilities & CAP_DFS) {
3013 smb_buffer->Flags2 |= SMBFLG2_DFS;
3015 if (ses->capabilities & CAP_UNICODE) {
3016 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3018 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3019 6 /* max utf8 char length in bytes */ *
3020 (/* server len*/ + 256 /* share len */), nls_codepage);
3021 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3022 bcc_ptr += 2; /* skip trailing null */
3023 } else { /* ASCII */
3024 strcpy(bcc_ptr, tree);
3025 bcc_ptr += strlen(tree) + 1;
3027 strcpy(bcc_ptr, "?????");
3028 bcc_ptr += strlen("?????");
3030 count = bcc_ptr - &pSMB->Password[0];
3031 pSMB->hdr.smb_buf_length += count;
3032 pSMB->ByteCount = cpu_to_le16(count);
3034 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3037 /* above now done in SendReceive */
3038 if ((rc == 0) && (tcon != NULL)) {
3041 tcon->tidStatus = CifsGood;
3042 tcon->need_reconnect = false;
3043 tcon->tid = smb_buffer_response->Tid;
3044 bcc_ptr = pByteArea(smb_buffer_response);
3045 bytes_left = get_bcc(smb_buffer_response);
3046 length = strnlen(bcc_ptr, bytes_left - 2);
3047 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3053 /* skip service field (NB: this field is always ASCII) */
3055 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3056 (bcc_ptr[2] == 'C')) {
3057 cFYI(1, "IPC connection");
3060 } else if (length == 2) {
3061 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3062 /* the most common case */
3063 cFYI(1, "disk share connection");
3066 bcc_ptr += length + 1;
3067 bytes_left -= (length + 1);
3068 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3070 /* mostly informational -- no need to fail on error here */
3071 kfree(tcon->nativeFileSystem);
3072 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3073 bytes_left, is_unicode,
3076 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3078 if ((smb_buffer_response->WordCount == 3) ||
3079 (smb_buffer_response->WordCount == 7))
3080 /* field is in same location */
3081 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3084 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3085 } else if ((rc == 0) && tcon == NULL) {
3086 /* all we need to save for IPC$ connection */
3087 ses->ipc_tid = smb_buffer_response->Tid;
3090 cifs_buf_release(smb_buffer);
3095 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3097 struct rb_root *root = &cifs_sb->tlink_tree;
3098 struct rb_node *node;
3099 struct tcon_link *tlink;
3102 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3104 spin_lock(&cifs_sb->tlink_tree_lock);
3105 while ((node = rb_first(root))) {
3106 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3107 cifs_get_tlink(tlink);
3108 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3109 rb_erase(node, root);
3111 spin_unlock(&cifs_sb->tlink_tree_lock);
3112 cifs_put_tlink(tlink);
3113 spin_lock(&cifs_sb->tlink_tree_lock);
3115 spin_unlock(&cifs_sb->tlink_tree_lock);
3117 tmp = cifs_sb->prepath;
3118 cifs_sb->prepathlen = 0;
3119 cifs_sb->prepath = NULL;
3125 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3128 struct TCP_Server_Info *server = ses->server;
3130 /* only send once per connect */
3131 if (server->maxBuf != 0)
3134 rc = CIFSSMBNegotiate(xid, ses);
3135 if (rc == -EAGAIN) {
3136 /* retry only once on 1st time connection */
3137 rc = CIFSSMBNegotiate(xid, ses);
3142 spin_lock(&GlobalMid_Lock);
3143 if (server->tcpStatus != CifsExiting)
3144 server->tcpStatus = CifsGood;
3147 spin_unlock(&GlobalMid_Lock);
3155 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3156 struct nls_table *nls_info)
3159 struct TCP_Server_Info *server = ses->server;
3162 ses->capabilities = server->capabilities;
3163 if (linuxExtEnabled == 0)
3164 ses->capabilities &= (~CAP_UNIX);
3166 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3167 server->secMode, server->capabilities, server->timeAdj);
3169 rc = CIFS_SessSetup(xid, ses, nls_info);
3171 cERROR(1, "Send error in SessSetup = %d", rc);
3173 mutex_lock(&ses->server->srv_mutex);
3174 if (!server->session_estab) {
3175 server->session_key.response = ses->auth_key.response;
3176 server->session_key.len = ses->auth_key.len;
3177 server->sequence_number = 0x2;
3178 server->session_estab = true;
3179 ses->auth_key.response = NULL;
3181 mutex_unlock(&server->srv_mutex);
3183 cFYI(1, "CIFS Session Established successfully");
3184 spin_lock(&GlobalMid_Lock);
3185 ses->status = CifsGood;
3186 ses->need_reconnect = false;
3187 spin_unlock(&GlobalMid_Lock);
3190 kfree(ses->auth_key.response);
3191 ses->auth_key.response = NULL;
3192 ses->auth_key.len = 0;
3193 kfree(ses->ntlmssp);
3194 ses->ntlmssp = NULL;
3199 static struct cifsTconInfo *
3200 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3202 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3203 struct cifsSesInfo *ses;
3204 struct cifsTconInfo *tcon = NULL;
3205 struct smb_vol *vol_info;
3206 char username[MAX_USERNAME_SIZE + 1];
3208 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3209 if (vol_info == NULL) {
3210 tcon = ERR_PTR(-ENOMEM);
3214 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3215 vol_info->username = username;
3216 vol_info->local_nls = cifs_sb->local_nls;
3217 vol_info->linux_uid = fsuid;
3218 vol_info->cred_uid = fsuid;
3219 vol_info->UNC = master_tcon->treeName;
3220 vol_info->retry = master_tcon->retry;
3221 vol_info->nocase = master_tcon->nocase;
3222 vol_info->local_lease = master_tcon->local_lease;
3223 vol_info->no_linux_ext = !master_tcon->unix_ext;
3225 /* FIXME: allow for other secFlg settings */
3226 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3228 /* get a reference for the same TCP session */
3229 spin_lock(&cifs_tcp_ses_lock);
3230 ++master_tcon->ses->server->srv_count;
3231 spin_unlock(&cifs_tcp_ses_lock);
3233 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3235 tcon = (struct cifsTconInfo *)ses;
3236 cifs_put_tcp_session(master_tcon->ses->server);
3240 tcon = cifs_get_tcon(ses, vol_info);
3242 cifs_put_smb_ses(ses);
3246 if (ses->capabilities & CAP_UNIX)
3247 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3254 static inline struct tcon_link *
3255 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3257 return cifs_sb->master_tlink;
3260 struct cifsTconInfo *
3261 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3263 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3267 cifs_sb_tcon_pending_wait(void *unused)
3270 return signal_pending(current) ? -ERESTARTSYS : 0;
3273 /* find and return a tlink with given uid */
3274 static struct tcon_link *
3275 tlink_rb_search(struct rb_root *root, uid_t uid)
3277 struct rb_node *node = root->rb_node;
3278 struct tcon_link *tlink;
3281 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3283 if (tlink->tl_uid > uid)
3284 node = node->rb_left;
3285 else if (tlink->tl_uid < uid)
3286 node = node->rb_right;
3293 /* insert a tcon_link into the tree */
3295 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3297 struct rb_node **new = &(root->rb_node), *parent = NULL;
3298 struct tcon_link *tlink;
3301 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3304 if (tlink->tl_uid > new_tlink->tl_uid)
3305 new = &((*new)->rb_left);
3307 new = &((*new)->rb_right);
3310 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3311 rb_insert_color(&new_tlink->tl_rbnode, root);
3315 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3318 * If the superblock doesn't refer to a multiuser mount, then just return
3319 * the master tcon for the mount.
3321 * First, search the rbtree for an existing tcon for this fsuid. If one
3322 * exists, then check to see if it's pending construction. If it is then wait
3323 * for construction to complete. Once it's no longer pending, check to see if
3324 * it failed and either return an error or retry construction, depending on
3327 * If one doesn't exist then insert a new tcon_link struct into the tree and
3328 * try to construct a new one.
3331 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3334 uid_t fsuid = current_fsuid();
3335 struct tcon_link *tlink, *newtlink;
3337 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3338 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3340 spin_lock(&cifs_sb->tlink_tree_lock);
3341 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3343 cifs_get_tlink(tlink);
3344 spin_unlock(&cifs_sb->tlink_tree_lock);
3346 if (tlink == NULL) {
3347 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3348 if (newtlink == NULL)
3349 return ERR_PTR(-ENOMEM);
3350 newtlink->tl_uid = fsuid;
3351 newtlink->tl_tcon = ERR_PTR(-EACCES);
3352 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3353 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3354 cifs_get_tlink(newtlink);
3356 spin_lock(&cifs_sb->tlink_tree_lock);
3357 /* was one inserted after previous search? */
3358 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3360 cifs_get_tlink(tlink);
3361 spin_unlock(&cifs_sb->tlink_tree_lock);
3363 goto wait_for_construction;
3366 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3367 spin_unlock(&cifs_sb->tlink_tree_lock);
3369 wait_for_construction:
3370 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3371 cifs_sb_tcon_pending_wait,
3372 TASK_INTERRUPTIBLE);
3374 cifs_put_tlink(tlink);
3375 return ERR_PTR(ret);
3378 /* if it's good, return it */
3379 if (!IS_ERR(tlink->tl_tcon))
3382 /* return error if we tried this already recently */
3383 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3384 cifs_put_tlink(tlink);
3385 return ERR_PTR(-EACCES);
3388 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3389 goto wait_for_construction;
3392 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3393 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3394 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3396 if (IS_ERR(tlink->tl_tcon)) {
3397 cifs_put_tlink(tlink);
3398 return ERR_PTR(-EACCES);
3405 * periodic workqueue job that scans tcon_tree for a superblock and closes
3409 cifs_prune_tlinks(struct work_struct *work)
3411 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3413 struct rb_root *root = &cifs_sb->tlink_tree;
3414 struct rb_node *node = rb_first(root);
3415 struct rb_node *tmp;
3416 struct tcon_link *tlink;
3419 * Because we drop the spinlock in the loop in order to put the tlink
3420 * it's not guarded against removal of links from the tree. The only
3421 * places that remove entries from the tree are this function and
3422 * umounts. Because this function is non-reentrant and is canceled
3423 * before umount can proceed, this is safe.
3425 spin_lock(&cifs_sb->tlink_tree_lock);
3426 node = rb_first(root);
3427 while (node != NULL) {
3429 node = rb_next(tmp);
3430 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3432 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3433 atomic_read(&tlink->tl_count) != 0 ||
3434 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3437 cifs_get_tlink(tlink);
3438 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3439 rb_erase(tmp, root);
3441 spin_unlock(&cifs_sb->tlink_tree_lock);
3442 cifs_put_tlink(tlink);
3443 spin_lock(&cifs_sb->tlink_tree_lock);
3445 spin_unlock(&cifs_sb->tlink_tree_lock);
3447 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,