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[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 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;
108 unsigned long actimeo; /* attribute cache timeout (jiffies) */
110 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
111 struct nls_table *local_nls;
114 /* FIXME: should these be tunable? */
115 #define TLINK_ERROR_EXPIRE (1 * HZ)
116 #define TLINK_IDLE_EXPIRE (600 * HZ)
118 static int ip_connect(struct TCP_Server_Info *server);
119 static int generic_ip_connect(struct TCP_Server_Info *server);
120 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
121 static void cifs_prune_tlinks(struct work_struct *work);
124 * cifs tcp session reconnection
126 * mark tcp session as reconnecting so temporarily locked
127 * mark all smb sessions as reconnecting for tcp session
128 * reconnect tcp session
129 * wake up waiters on reconnection? - (not needed currently)
132 cifs_reconnect(struct TCP_Server_Info *server)
135 struct list_head *tmp, *tmp2;
136 struct cifsSesInfo *ses;
137 struct cifsTconInfo *tcon;
138 struct mid_q_entry *mid_entry;
140 spin_lock(&GlobalMid_Lock);
141 if (server->tcpStatus == CifsExiting) {
142 /* the demux thread will exit normally
143 next time through the loop */
144 spin_unlock(&GlobalMid_Lock);
147 server->tcpStatus = CifsNeedReconnect;
148 spin_unlock(&GlobalMid_Lock);
151 cFYI(1, "Reconnecting tcp session");
153 /* before reconnecting the tcp session, mark the smb session (uid)
154 and the tid bad so they are not used until reconnected */
155 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
156 spin_lock(&cifs_tcp_ses_lock);
157 list_for_each(tmp, &server->smb_ses_list) {
158 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
159 ses->need_reconnect = true;
161 list_for_each(tmp2, &ses->tcon_list) {
162 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
163 tcon->need_reconnect = true;
166 spin_unlock(&cifs_tcp_ses_lock);
168 /* do not want to be sending data on a socket we are freeing */
169 cFYI(1, "%s: tearing down socket", __func__);
170 mutex_lock(&server->srv_mutex);
171 if (server->ssocket) {
172 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
173 server->ssocket->flags);
174 kernel_sock_shutdown(server->ssocket, SHUT_WR);
175 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
176 server->ssocket->state,
177 server->ssocket->flags);
178 sock_release(server->ssocket);
179 server->ssocket = NULL;
181 server->sequence_number = 0;
182 server->session_estab = false;
183 kfree(server->session_key.response);
184 server->session_key.response = NULL;
185 server->session_key.len = 0;
186 mutex_unlock(&server->srv_mutex);
188 /* mark submitted MIDs for retry and issue callback */
189 cFYI(1, "%s: issuing mid callbacks", __func__);
190 spin_lock(&GlobalMid_Lock);
191 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
192 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
193 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
194 mid_entry->midState = MID_RETRY_NEEDED;
195 list_del_init(&mid_entry->qhead);
196 mid_entry->callback(mid_entry);
198 spin_unlock(&GlobalMid_Lock);
200 while ((server->tcpStatus != CifsExiting) &&
201 (server->tcpStatus != CifsGood)) {
204 /* we should try only the port we connected to before */
205 rc = generic_ip_connect(server);
207 cFYI(1, "reconnect error %d", rc);
210 atomic_inc(&tcpSesReconnectCount);
211 spin_lock(&GlobalMid_Lock);
212 if (server->tcpStatus != CifsExiting)
213 server->tcpStatus = CifsGood;
214 spin_unlock(&GlobalMid_Lock);
223 0 not a transact2, or all data present
224 >0 transact2 with that much data missing
225 -EINVAL = invalid transact2
228 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
230 struct smb_t2_rsp *pSMBt;
232 int data_in_this_rsp;
235 if (pSMB->Command != SMB_COM_TRANSACTION2)
238 /* check for plausible wct, bcc and t2 data and parm sizes */
239 /* check for parm and data offset going beyond end of smb */
240 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
241 cFYI(1, "invalid transact2 word count");
245 pSMBt = (struct smb_t2_rsp *)pSMB;
247 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
248 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
250 remaining = total_data_size - data_in_this_rsp;
254 else if (remaining < 0) {
255 cFYI(1, "total data %d smaller than data in frame %d",
256 total_data_size, data_in_this_rsp);
259 cFYI(1, "missing %d bytes from transact2, check next response",
261 if (total_data_size > maxBufSize) {
262 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
263 total_data_size, maxBufSize);
270 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
272 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
273 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
278 char *data_area_of_target;
279 char *data_area_of_buf2;
282 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
284 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
285 cFYI(1, "total data size of primary and secondary t2 differ");
288 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
290 remaining = total_data_size - total_in_buf;
295 if (remaining == 0) /* nothing to do, ignore */
298 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
299 if (remaining < total_in_buf2) {
300 cFYI(1, "transact2 2nd response contains too much data");
303 /* find end of first SMB data area */
304 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
305 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
306 /* validate target area */
308 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
309 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
311 data_area_of_target += total_in_buf;
313 /* copy second buffer into end of first buffer */
314 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
315 total_in_buf += total_in_buf2;
316 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
317 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
318 byte_count += total_in_buf2;
319 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
321 byte_count = pTargetSMB->smb_buf_length;
322 byte_count += total_in_buf2;
324 /* BB also add check that we are not beyond maximum buffer size */
326 pTargetSMB->smb_buf_length = byte_count;
328 if (remaining == total_in_buf2) {
329 cFYI(1, "found the last secondary response");
330 return 0; /* we are done */
331 } else /* more responses to go */
337 cifs_demultiplex_thread(struct TCP_Server_Info *server)
340 unsigned int pdu_length, total_read;
341 struct smb_hdr *smb_buffer = NULL;
342 struct smb_hdr *bigbuf = NULL;
343 struct smb_hdr *smallbuf = NULL;
344 struct msghdr smb_msg;
346 struct socket *csocket = server->ssocket;
347 struct list_head *tmp, *tmp2;
348 struct task_struct *task_to_wake = NULL;
349 struct mid_q_entry *mid_entry;
351 bool isLargeBuf = false;
355 current->flags |= PF_MEMALLOC;
356 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
358 length = atomic_inc_return(&tcpSesAllocCount);
360 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
364 while (server->tcpStatus != CifsExiting) {
367 if (bigbuf == NULL) {
368 bigbuf = cifs_buf_get();
370 cERROR(1, "No memory for large SMB response");
372 /* retry will check if exiting */
375 } else if (isLargeBuf) {
376 /* we are reusing a dirty large buf, clear its start */
377 memset(bigbuf, 0, sizeof(struct smb_hdr));
380 if (smallbuf == NULL) {
381 smallbuf = cifs_small_buf_get();
383 cERROR(1, "No memory for SMB response");
385 /* retry will check if exiting */
388 /* beginning of smb buffer is cleared in our buf_get */
389 } else /* if existing small buf clear beginning */
390 memset(smallbuf, 0, sizeof(struct smb_hdr));
394 smb_buffer = smallbuf;
395 iov.iov_base = smb_buffer;
397 smb_msg.msg_control = NULL;
398 smb_msg.msg_controllen = 0;
399 pdu_length = 4; /* enough to get RFC1001 header */
402 kernel_recvmsg(csocket, &smb_msg,
403 &iov, 1, pdu_length, 0 /* BB other flags? */);
405 if (server->tcpStatus == CifsExiting) {
407 } else if (server->tcpStatus == CifsNeedReconnect) {
408 cFYI(1, "Reconnect after server stopped responding");
409 cifs_reconnect(server);
410 cFYI(1, "call to reconnect done");
411 csocket = server->ssocket;
413 } else if (length == -ERESTARTSYS ||
416 msleep(1); /* minimum sleep to prevent looping
417 allowing socket to clear and app threads to set
418 tcpStatus CifsNeedReconnect if server hung */
419 if (pdu_length < 4) {
420 iov.iov_base = (4 - pdu_length) +
422 iov.iov_len = pdu_length;
423 smb_msg.msg_control = NULL;
424 smb_msg.msg_controllen = 0;
428 } else if (length <= 0) {
429 cFYI(1, "Reconnect after unexpected peek error %d",
431 cifs_reconnect(server);
432 csocket = server->ssocket;
433 wake_up(&server->response_q);
435 } else if (length < pdu_length) {
436 cFYI(1, "requested %d bytes but only got %d bytes",
438 pdu_length -= length;
443 /* The right amount was read from socket - 4 bytes */
444 /* so we can now interpret the length field */
446 /* the first byte big endian of the length field,
447 is actually not part of the length but the type
448 with the most common, zero, as regular data */
449 temp = *((char *) smb_buffer);
451 /* Note that FC 1001 length is big endian on the wire,
452 but we convert it here so it is always manipulated
453 as host byte order */
454 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
455 smb_buffer->smb_buf_length = pdu_length;
457 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
459 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
461 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
462 cFYI(1, "Good RFC 1002 session rsp");
464 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
465 /* we get this from Windows 98 instead of
466 an error on SMB negprot response */
467 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
469 /* give server a second to clean up */
471 /* always try 445 first on reconnect since we get NACK
472 * on some if we ever connected to port 139 (the NACK
473 * is since we do not begin with RFC1001 session
476 cifs_set_port((struct sockaddr *)
477 &server->dstaddr, CIFS_PORT);
478 cifs_reconnect(server);
479 csocket = server->ssocket;
480 wake_up(&server->response_q);
482 } else if (temp != (char) 0) {
483 cERROR(1, "Unknown RFC 1002 frame");
484 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
486 cifs_reconnect(server);
487 csocket = server->ssocket;
491 /* else we have an SMB response */
492 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
493 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
494 cERROR(1, "Invalid size SMB length %d pdu_length %d",
495 length, pdu_length+4);
496 cifs_reconnect(server);
497 csocket = server->ssocket;
498 wake_up(&server->response_q);
505 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
507 memcpy(bigbuf, smallbuf, 4);
511 iov.iov_base = 4 + (char *)smb_buffer;
512 iov.iov_len = pdu_length;
513 for (total_read = 0; total_read < pdu_length;
514 total_read += length) {
515 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
516 pdu_length - total_read, 0);
517 if (server->tcpStatus == CifsExiting) {
521 } else if (server->tcpStatus == CifsNeedReconnect) {
522 cifs_reconnect(server);
523 csocket = server->ssocket;
524 /* Reconnect wakes up rspns q */
525 /* Now we will reread sock */
528 } else if (length == -ERESTARTSYS ||
531 msleep(1); /* minimum sleep to prevent looping,
532 allowing socket to clear and app
533 threads to set tcpStatus
534 CifsNeedReconnect if server hung*/
537 } else if (length <= 0) {
538 cERROR(1, "Received no data, expecting %d",
539 pdu_length - total_read);
540 cifs_reconnect(server);
541 csocket = server->ssocket;
548 else if (reconnect == 1)
551 length += 4; /* account for rfc1002 hdr */
554 dump_smb(smb_buffer, length);
555 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
556 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
561 spin_lock(&GlobalMid_Lock);
562 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
563 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
565 if ((mid_entry->mid == smb_buffer->Mid) &&
566 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
567 (mid_entry->command == smb_buffer->Command)) {
568 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
569 /* We have a multipart transact2 resp */
571 if (mid_entry->resp_buf) {
572 /* merge response - fix up 1st*/
573 if (coalesce_t2(smb_buffer,
574 mid_entry->resp_buf)) {
575 mid_entry->multiRsp =
579 /* all parts received */
580 mid_entry->multiEnd =
586 cERROR(1, "1st trans2 resp needs bigbuf");
587 /* BB maybe we can fix this up, switch
588 to already allocated large buffer? */
590 /* Have first buffer */
591 mid_entry->resp_buf =
593 mid_entry->largeBuf =
600 mid_entry->resp_buf = smb_buffer;
601 mid_entry->largeBuf = isLargeBuf;
603 mid_entry->midState = MID_RESPONSE_RECEIVED;
604 list_del_init(&mid_entry->qhead);
605 mid_entry->callback(mid_entry);
606 #ifdef CONFIG_CIFS_STATS2
607 mid_entry->when_received = jiffies;
609 /* so we do not time out requests to server
610 which is still responding (since server could
611 be busy but not dead) */
612 server->lstrp = jiffies;
617 spin_unlock(&GlobalMid_Lock);
619 if (mid_entry != NULL) {
620 /* Was previous buf put in mpx struct for multi-rsp? */
622 /* smb buffer will be freed by user thread */
628 } else if (!is_valid_oplock_break(smb_buffer, server) &&
630 cERROR(1, "No task to wake, unknown frame received! "
631 "NumMids %d", atomic_read(&midCount));
632 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
633 sizeof(struct smb_hdr));
634 #ifdef CONFIG_CIFS_DEBUG2
635 cifs_dump_detail(smb_buffer);
636 cifs_dump_mids(server);
637 #endif /* CIFS_DEBUG2 */
640 } /* end while !EXITING */
642 /* take it off the list, if it's not already */
643 spin_lock(&cifs_tcp_ses_lock);
644 list_del_init(&server->tcp_ses_list);
645 spin_unlock(&cifs_tcp_ses_lock);
647 spin_lock(&GlobalMid_Lock);
648 server->tcpStatus = CifsExiting;
649 spin_unlock(&GlobalMid_Lock);
650 wake_up_all(&server->response_q);
652 /* check if we have blocked requests that need to free */
653 /* Note that cifs_max_pending is normally 50, but
654 can be set at module install time to as little as two */
655 spin_lock(&GlobalMid_Lock);
656 if (atomic_read(&server->inFlight) >= cifs_max_pending)
657 atomic_set(&server->inFlight, cifs_max_pending - 1);
658 /* We do not want to set the max_pending too low or we
659 could end up with the counter going negative */
660 spin_unlock(&GlobalMid_Lock);
661 /* Although there should not be any requests blocked on
662 this queue it can not hurt to be paranoid and try to wake up requests
663 that may haven been blocked when more than 50 at time were on the wire
664 to the same server - they now will see the session is in exit state
665 and get out of SendReceive. */
666 wake_up_all(&server->request_q);
667 /* give those requests time to exit */
670 if (server->ssocket) {
671 sock_release(csocket);
672 server->ssocket = NULL;
674 /* buffer usuallly freed in free_mid - need to free it here on exit */
675 cifs_buf_release(bigbuf);
676 if (smallbuf) /* no sense logging a debug message if NULL */
677 cifs_small_buf_release(smallbuf);
679 if (!list_empty(&server->pending_mid_q)) {
680 spin_lock(&GlobalMid_Lock);
681 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
682 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
683 cFYI(1, "Clearing Mid 0x%x - issuing callback",
685 list_del_init(&mid_entry->qhead);
686 mid_entry->callback(mid_entry);
688 spin_unlock(&GlobalMid_Lock);
689 /* 1/8th of sec is more than enough time for them to exit */
693 if (!list_empty(&server->pending_mid_q)) {
694 /* mpx threads have not exited yet give them
695 at least the smb send timeout time for long ops */
696 /* due to delays on oplock break requests, we need
697 to wait at least 45 seconds before giving up
698 on a request getting a response and going ahead
700 cFYI(1, "Wait for exit from demultiplex thread");
702 /* if threads still have not exited they are probably never
703 coming home not much else we can do but free the memory */
706 kfree(server->hostname);
707 task_to_wake = xchg(&server->tsk, NULL);
710 length = atomic_dec_return(&tcpSesAllocCount);
712 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
715 /* if server->tsk was NULL then wait for a signal before exiting */
717 set_current_state(TASK_INTERRUPTIBLE);
718 while (!signal_pending(current)) {
720 set_current_state(TASK_INTERRUPTIBLE);
722 set_current_state(TASK_RUNNING);
725 module_put_and_exit(0);
728 /* extract the host portion of the UNC string */
730 extract_hostname(const char *unc)
736 /* skip double chars at beginning of string */
737 /* BB: check validity of these bytes? */
740 /* delimiter between hostname and sharename is always '\\' now */
741 delim = strchr(src, '\\');
743 return ERR_PTR(-EINVAL);
746 dst = kmalloc((len + 1), GFP_KERNEL);
748 return ERR_PTR(-ENOMEM);
750 memcpy(dst, src, len);
757 cifs_parse_mount_options(char *options, const char *devname,
762 unsigned int temp_len, i, j;
764 short int override_uid = -1;
765 short int override_gid = -1;
766 bool uid_specified = false;
767 bool gid_specified = false;
768 char *nodename = utsname()->nodename;
774 * does not have to be perfect mapping since field is
775 * informational, only used for servers that do not support
776 * port 445 and it can be overridden at mount time
778 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
779 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
780 vol->source_rfc1001_name[i] = toupper(nodename[i]);
782 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
783 /* null target name indicates to use *SMBSERVR default called name
784 if we end up sending RFC1001 session initialize */
785 vol->target_rfc1001_name[0] = 0;
786 vol->cred_uid = current_uid();
787 vol->linux_uid = current_uid();
788 vol->linux_gid = current_gid();
790 /* default to only allowing write access to owner of the mount */
791 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
793 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
794 /* default is always to request posix paths. */
795 vol->posix_paths = 1;
796 /* default to using server inode numbers where available */
799 vol->actimeo = CIFS_DEF_ACTIMEO;
804 if (strncmp(options, "sep=", 4) == 0) {
805 if (options[4] != 0) {
806 separator[0] = options[4];
809 cFYI(1, "Null separator not allowed");
813 while ((data = strsep(&options, separator)) != NULL) {
816 if ((value = strchr(data, '=')) != NULL)
819 /* Have to parse this before we parse for "user" */
820 if (strnicmp(data, "user_xattr", 10) == 0) {
822 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
824 } else if (strnicmp(data, "user", 4) == 0) {
827 "CIFS: invalid or missing username\n");
828 return 1; /* needs_arg; */
829 } else if (!*value) {
830 /* null user, ie anonymous, authentication */
833 if (strnlen(value, 200) < 200) {
834 vol->username = value;
836 printk(KERN_WARNING "CIFS: username too long\n");
839 } else if (strnicmp(data, "pass", 4) == 0) {
841 vol->password = NULL;
843 } else if (value[0] == 0) {
844 /* check if string begins with double comma
845 since that would mean the password really
846 does start with a comma, and would not
847 indicate an empty string */
848 if (value[1] != separator[0]) {
849 vol->password = NULL;
853 temp_len = strlen(value);
854 /* removed password length check, NTLM passwords
855 can be arbitrarily long */
857 /* if comma in password, the string will be
858 prematurely null terminated. Commas in password are
859 specified across the cifs mount interface by a double
860 comma ie ,, and a comma used as in other cases ie ','
861 as a parameter delimiter/separator is single and due
862 to the strsep above is temporarily zeroed. */
864 /* NB: password legally can have multiple commas and
865 the only illegal character in a password is null */
867 if ((value[temp_len] == 0) &&
868 (value[temp_len+1] == separator[0])) {
870 value[temp_len] = separator[0];
871 temp_len += 2; /* move after second comma */
872 while (value[temp_len] != 0) {
873 if (value[temp_len] == separator[0]) {
874 if (value[temp_len+1] ==
876 /* skip second comma */
879 /* single comma indicating start
886 if (value[temp_len] == 0) {
890 /* point option to start of next parm */
891 options = value + temp_len + 1;
893 /* go from value to value + temp_len condensing
894 double commas to singles. Note that this ends up
895 allocating a few bytes too many, which is ok */
896 vol->password = kzalloc(temp_len, GFP_KERNEL);
897 if (vol->password == NULL) {
898 printk(KERN_WARNING "CIFS: no memory "
902 for (i = 0, j = 0; i < temp_len; i++, j++) {
903 vol->password[j] = value[i];
904 if (value[i] == separator[0]
905 && value[i+1] == separator[0]) {
906 /* skip second comma */
910 vol->password[j] = 0;
912 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
913 if (vol->password == NULL) {
914 printk(KERN_WARNING "CIFS: no memory "
918 strcpy(vol->password, value);
920 } else if (!strnicmp(data, "ip", 2) ||
921 !strnicmp(data, "addr", 4)) {
922 if (!value || !*value) {
924 } else if (strnlen(value, INET6_ADDRSTRLEN) <
928 printk(KERN_WARNING "CIFS: ip address "
932 } else if (strnicmp(data, "sec", 3) == 0) {
933 if (!value || !*value) {
934 cERROR(1, "no security value specified");
936 } else if (strnicmp(value, "krb5i", 5) == 0) {
937 vol->secFlg |= CIFSSEC_MAY_KRB5 |
939 } else if (strnicmp(value, "krb5p", 5) == 0) {
940 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
942 cERROR(1, "Krb5 cifs privacy not supported");
944 } else if (strnicmp(value, "krb5", 4) == 0) {
945 vol->secFlg |= CIFSSEC_MAY_KRB5;
946 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
947 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
949 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
950 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
951 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
952 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
954 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
955 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
956 } else if (strnicmp(value, "ntlmi", 5) == 0) {
957 vol->secFlg |= CIFSSEC_MAY_NTLM |
959 } else if (strnicmp(value, "ntlm", 4) == 0) {
960 /* ntlm is default so can be turned off too */
961 vol->secFlg |= CIFSSEC_MAY_NTLM;
962 } else if (strnicmp(value, "nontlm", 6) == 0) {
963 /* BB is there a better way to do this? */
964 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
965 #ifdef CONFIG_CIFS_WEAK_PW_HASH
966 } else if (strnicmp(value, "lanman", 6) == 0) {
967 vol->secFlg |= CIFSSEC_MAY_LANMAN;
969 } else if (strnicmp(value, "none", 4) == 0) {
972 cERROR(1, "bad security option: %s", value);
975 } else if ((strnicmp(data, "unc", 3) == 0)
976 || (strnicmp(data, "target", 6) == 0)
977 || (strnicmp(data, "path", 4) == 0)) {
978 if (!value || !*value) {
979 printk(KERN_WARNING "CIFS: invalid path to "
980 "network resource\n");
981 return 1; /* needs_arg; */
983 if ((temp_len = strnlen(value, 300)) < 300) {
984 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
985 if (vol->UNC == NULL)
987 strcpy(vol->UNC, value);
988 if (strncmp(vol->UNC, "//", 2) == 0) {
991 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
993 "CIFS: UNC Path does not begin "
994 "with // or \\\\ \n");
998 printk(KERN_WARNING "CIFS: UNC name too long\n");
1001 } else if ((strnicmp(data, "domain", 3) == 0)
1002 || (strnicmp(data, "workgroup", 5) == 0)) {
1003 if (!value || !*value) {
1004 printk(KERN_WARNING "CIFS: invalid domain name\n");
1005 return 1; /* needs_arg; */
1007 /* BB are there cases in which a comma can be valid in
1008 a domain name and need special handling? */
1009 if (strnlen(value, 256) < 256) {
1010 vol->domainname = value;
1011 cFYI(1, "Domain name set");
1013 printk(KERN_WARNING "CIFS: domain name too "
1017 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1018 vol->srcaddr.ss_family = AF_UNSPEC;
1020 if (!value || !*value) {
1021 printk(KERN_WARNING "CIFS: srcaddr value"
1022 " not specified.\n");
1023 return 1; /* needs_arg; */
1025 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1026 value, strlen(value));
1028 printk(KERN_WARNING "CIFS: Could not parse"
1033 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1034 if (!value || !*value) {
1036 "CIFS: invalid path prefix\n");
1037 return 1; /* needs_argument */
1039 if ((temp_len = strnlen(value, 1024)) < 1024) {
1040 if (value[0] != '/')
1041 temp_len++; /* missing leading slash */
1042 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1043 if (vol->prepath == NULL)
1045 if (value[0] != '/') {
1046 vol->prepath[0] = '/';
1047 strcpy(vol->prepath+1, value);
1049 strcpy(vol->prepath, value);
1050 cFYI(1, "prefix path %s", vol->prepath);
1052 printk(KERN_WARNING "CIFS: prefix too long\n");
1055 } else if (strnicmp(data, "iocharset", 9) == 0) {
1056 if (!value || !*value) {
1057 printk(KERN_WARNING "CIFS: invalid iocharset "
1059 return 1; /* needs_arg; */
1061 if (strnlen(value, 65) < 65) {
1062 if (strnicmp(value, "default", 7))
1063 vol->iocharset = value;
1064 /* if iocharset not set then load_nls_default
1065 is used by caller */
1066 cFYI(1, "iocharset set to %s", value);
1068 printk(KERN_WARNING "CIFS: iocharset name "
1072 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1073 vol->linux_uid = simple_strtoul(value, &value, 0);
1074 uid_specified = true;
1075 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1076 vol->cred_uid = simple_strtoul(value, &value, 0);
1077 } else if (!strnicmp(data, "forceuid", 8)) {
1079 } else if (!strnicmp(data, "noforceuid", 10)) {
1081 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1082 vol->linux_gid = simple_strtoul(value, &value, 0);
1083 gid_specified = true;
1084 } else if (!strnicmp(data, "forcegid", 8)) {
1086 } else if (!strnicmp(data, "noforcegid", 10)) {
1088 } else if (strnicmp(data, "file_mode", 4) == 0) {
1089 if (value && *value) {
1091 simple_strtoul(value, &value, 0);
1093 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1094 if (value && *value) {
1096 simple_strtoul(value, &value, 0);
1098 } else if (strnicmp(data, "dirmode", 4) == 0) {
1099 if (value && *value) {
1101 simple_strtoul(value, &value, 0);
1103 } else if (strnicmp(data, "port", 4) == 0) {
1104 if (value && *value) {
1106 simple_strtoul(value, &value, 0);
1108 } else if (strnicmp(data, "rsize", 5) == 0) {
1109 if (value && *value) {
1111 simple_strtoul(value, &value, 0);
1113 } else if (strnicmp(data, "wsize", 5) == 0) {
1114 if (value && *value) {
1116 simple_strtoul(value, &value, 0);
1118 } else if (strnicmp(data, "sockopt", 5) == 0) {
1119 if (!value || !*value) {
1120 cERROR(1, "no socket option specified");
1122 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1123 vol->sockopt_tcp_nodelay = 1;
1125 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1126 if (!value || !*value || (*value == ' ')) {
1127 cFYI(1, "invalid (empty) netbiosname");
1129 memset(vol->source_rfc1001_name, 0x20,
1132 * FIXME: are there cases in which a comma can
1133 * be valid in workstation netbios name (and
1134 * need special handling)?
1136 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1137 /* don't ucase netbiosname for user */
1140 vol->source_rfc1001_name[i] = value[i];
1142 /* The string has 16th byte zero still from
1143 set at top of the function */
1144 if (i == RFC1001_NAME_LEN && value[i] != 0)
1145 printk(KERN_WARNING "CIFS: netbiosname"
1146 " longer than 15 truncated.\n");
1148 } else if (strnicmp(data, "servern", 7) == 0) {
1149 /* servernetbiosname specified override *SMBSERVER */
1150 if (!value || !*value || (*value == ' ')) {
1151 cFYI(1, "empty server netbiosname specified");
1153 /* last byte, type, is 0x20 for servr type */
1154 memset(vol->target_rfc1001_name, 0x20,
1155 RFC1001_NAME_LEN_WITH_NULL);
1157 for (i = 0; i < 15; i++) {
1158 /* BB are there cases in which a comma can be
1159 valid in this workstation netbios name
1160 (and need special handling)? */
1162 /* user or mount helper must uppercase
1167 vol->target_rfc1001_name[i] =
1170 /* The string has 16th byte zero still from
1171 set at top of the function */
1172 if (i == RFC1001_NAME_LEN && value[i] != 0)
1173 printk(KERN_WARNING "CIFS: server net"
1174 "biosname longer than 15 truncated.\n");
1176 } else if (strnicmp(data, "actimeo", 7) == 0) {
1177 if (value && *value) {
1178 vol->actimeo = HZ * simple_strtoul(value,
1180 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1181 cERROR(1, "CIFS: attribute cache"
1182 "timeout too large");
1186 } else if (strnicmp(data, "credentials", 4) == 0) {
1188 } else if (strnicmp(data, "version", 3) == 0) {
1190 } else if (strnicmp(data, "guest", 5) == 0) {
1192 } else if (strnicmp(data, "rw", 2) == 0) {
1194 } else if (strnicmp(data, "ro", 2) == 0) {
1196 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1197 vol->noblocksnd = 1;
1198 } else if (strnicmp(data, "noautotune", 10) == 0) {
1199 vol->noautotune = 1;
1200 } else if ((strnicmp(data, "suid", 4) == 0) ||
1201 (strnicmp(data, "nosuid", 6) == 0) ||
1202 (strnicmp(data, "exec", 4) == 0) ||
1203 (strnicmp(data, "noexec", 6) == 0) ||
1204 (strnicmp(data, "nodev", 5) == 0) ||
1205 (strnicmp(data, "noauto", 6) == 0) ||
1206 (strnicmp(data, "dev", 3) == 0)) {
1207 /* The mount tool or mount.cifs helper (if present)
1208 uses these opts to set flags, and the flags are read
1209 by the kernel vfs layer before we get here (ie
1210 before read super) so there is no point trying to
1211 parse these options again and set anything and it
1212 is ok to just ignore them */
1214 } else if (strnicmp(data, "hard", 4) == 0) {
1216 } else if (strnicmp(data, "soft", 4) == 0) {
1218 } else if (strnicmp(data, "perm", 4) == 0) {
1220 } else if (strnicmp(data, "noperm", 6) == 0) {
1222 } else if (strnicmp(data, "mapchars", 8) == 0) {
1224 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1226 } else if (strnicmp(data, "sfu", 3) == 0) {
1228 } else if (strnicmp(data, "nosfu", 5) == 0) {
1230 } else if (strnicmp(data, "nodfs", 5) == 0) {
1232 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1233 vol->posix_paths = 1;
1234 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1235 vol->posix_paths = 0;
1236 } else if (strnicmp(data, "nounix", 6) == 0) {
1237 vol->no_linux_ext = 1;
1238 } else if (strnicmp(data, "nolinux", 7) == 0) {
1239 vol->no_linux_ext = 1;
1240 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1241 (strnicmp(data, "ignorecase", 10) == 0)) {
1243 } else if (strnicmp(data, "mand", 4) == 0) {
1245 } else if (strnicmp(data, "nomand", 6) == 0) {
1247 } else if (strnicmp(data, "_netdev", 7) == 0) {
1249 } else if (strnicmp(data, "brl", 3) == 0) {
1251 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1252 (strnicmp(data, "nolock", 6) == 0)) {
1254 /* turn off mandatory locking in mode
1255 if remote locking is turned off since the
1256 local vfs will do advisory */
1257 if (vol->file_mode ==
1258 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1259 vol->file_mode = S_IALLUGO;
1260 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1261 /* will take the shorter form "forcemand" as well */
1262 /* This mount option will force use of mandatory
1263 (DOS/Windows style) byte range locks, instead of
1264 using posix advisory byte range locks, even if the
1265 Unix extensions are available and posix locks would
1266 be supported otherwise. If Unix extensions are not
1267 negotiated this has no effect since mandatory locks
1268 would be used (mandatory locks is all that those
1269 those servers support) */
1271 } else if (strnicmp(data, "setuids", 7) == 0) {
1273 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1275 } else if (strnicmp(data, "dynperm", 7) == 0) {
1276 vol->dynperm = true;
1277 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1278 vol->dynperm = false;
1279 } else if (strnicmp(data, "nohard", 6) == 0) {
1281 } else if (strnicmp(data, "nosoft", 6) == 0) {
1283 } else if (strnicmp(data, "nointr", 6) == 0) {
1285 } else if (strnicmp(data, "intr", 4) == 0) {
1287 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1288 vol->nostrictsync = 1;
1289 } else if (strnicmp(data, "strictsync", 10) == 0) {
1290 vol->nostrictsync = 0;
1291 } else if (strnicmp(data, "serverino", 7) == 0) {
1292 vol->server_ino = 1;
1293 } else if (strnicmp(data, "noserverino", 9) == 0) {
1294 vol->server_ino = 0;
1295 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1297 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1299 } else if (strnicmp(data, "acl", 3) == 0) {
1300 vol->no_psx_acl = 0;
1301 } else if (strnicmp(data, "noacl", 5) == 0) {
1302 vol->no_psx_acl = 1;
1303 } else if (strnicmp(data, "locallease", 6) == 0) {
1304 vol->local_lease = 1;
1305 } else if (strnicmp(data, "sign", 4) == 0) {
1306 vol->secFlg |= CIFSSEC_MUST_SIGN;
1307 } else if (strnicmp(data, "seal", 4) == 0) {
1308 /* we do not do the following in secFlags because seal
1309 is a per tree connection (mount) not a per socket
1310 or per-smb connection option in the protocol */
1311 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1313 } else if (strnicmp(data, "direct", 6) == 0) {
1315 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1317 } else if (strnicmp(data, "noac", 4) == 0) {
1318 printk(KERN_WARNING "CIFS: Mount option noac not "
1319 "supported. Instead set "
1320 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1321 } else if (strnicmp(data, "fsc", 3) == 0) {
1322 #ifndef CONFIG_CIFS_FSCACHE
1323 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1324 "kernel config option set");
1328 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1329 vol->mfsymlinks = true;
1330 } else if (strnicmp(data, "multiuser", 8) == 0) {
1331 vol->multiuser = true;
1333 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1336 if (vol->UNC == NULL) {
1337 if (devname == NULL) {
1338 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1342 if ((temp_len = strnlen(devname, 300)) < 300) {
1343 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1344 if (vol->UNC == NULL)
1346 strcpy(vol->UNC, devname);
1347 if (strncmp(vol->UNC, "//", 2) == 0) {
1350 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1351 printk(KERN_WARNING "CIFS: UNC Path does not "
1352 "begin with // or \\\\ \n");
1355 value = strpbrk(vol->UNC+2, "/\\");
1359 printk(KERN_WARNING "CIFS: UNC name too long\n");
1364 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1365 cERROR(1, "Multiuser mounts currently require krb5 "
1370 if (vol->UNCip == NULL)
1371 vol->UNCip = &vol->UNC[2];
1374 vol->override_uid = override_uid;
1375 else if (override_uid == 1)
1376 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1377 "specified with no uid= option.\n");
1380 vol->override_gid = override_gid;
1381 else if (override_gid == 1)
1382 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1383 "specified with no gid= option.\n");
1388 /** Returns true if srcaddr isn't specified and rhs isn't
1389 * specified, or if srcaddr is specified and
1390 * matches the IP address of the rhs argument.
1393 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1395 switch (srcaddr->sa_family) {
1397 return (rhs->sa_family == AF_UNSPEC);
1399 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1400 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1401 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1404 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1405 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1406 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1410 return false; /* don't expect to be here */
1415 * If no port is specified in addr structure, we try to match with 445 port
1416 * and if it fails - with 139 ports. It should be called only if address
1417 * families of server and addr are equal.
1420 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1422 unsigned short int port, *sport;
1424 switch (addr->sa_family) {
1426 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1427 port = ((struct sockaddr_in *) addr)->sin_port;
1430 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1431 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1439 port = htons(CIFS_PORT);
1443 port = htons(RFC1001_PORT);
1446 return port == *sport;
1450 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1451 struct sockaddr *srcaddr)
1453 switch (addr->sa_family) {
1455 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1456 struct sockaddr_in *srv_addr4 =
1457 (struct sockaddr_in *)&server->dstaddr;
1459 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1464 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1465 struct sockaddr_in6 *srv_addr6 =
1466 (struct sockaddr_in6 *)&server->dstaddr;
1468 if (!ipv6_addr_equal(&addr6->sin6_addr,
1469 &srv_addr6->sin6_addr))
1471 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1477 return false; /* don't expect to be here */
1480 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1487 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1489 unsigned int secFlags;
1491 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1492 secFlags = vol->secFlg;
1494 secFlags = global_secflags | vol->secFlg;
1496 switch (server->secType) {
1498 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1502 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1506 if (!(secFlags & CIFSSEC_MAY_NTLM))
1510 if (!(secFlags & CIFSSEC_MAY_KRB5))
1514 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1518 /* shouldn't happen */
1522 /* now check if signing mode is acceptible */
1523 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1524 (server->secMode & SECMODE_SIGN_REQUIRED))
1526 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1528 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1534 static struct TCP_Server_Info *
1535 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1537 struct TCP_Server_Info *server;
1539 spin_lock(&cifs_tcp_ses_lock);
1540 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1541 if (!match_address(server, addr,
1542 (struct sockaddr *)&vol->srcaddr))
1545 if (!match_port(server, addr))
1548 if (!match_security(server, vol))
1551 ++server->srv_count;
1552 spin_unlock(&cifs_tcp_ses_lock);
1553 cFYI(1, "Existing tcp session with server found");
1556 spin_unlock(&cifs_tcp_ses_lock);
1561 cifs_put_tcp_session(struct TCP_Server_Info *server)
1563 struct task_struct *task;
1565 spin_lock(&cifs_tcp_ses_lock);
1566 if (--server->srv_count > 0) {
1567 spin_unlock(&cifs_tcp_ses_lock);
1571 list_del_init(&server->tcp_ses_list);
1572 spin_unlock(&cifs_tcp_ses_lock);
1574 spin_lock(&GlobalMid_Lock);
1575 server->tcpStatus = CifsExiting;
1576 spin_unlock(&GlobalMid_Lock);
1578 cifs_crypto_shash_release(server);
1579 cifs_fscache_release_client_cookie(server);
1581 kfree(server->session_key.response);
1582 server->session_key.response = NULL;
1583 server->session_key.len = 0;
1585 task = xchg(&server->tsk, NULL);
1587 force_sig(SIGKILL, task);
1590 static struct TCP_Server_Info *
1591 cifs_get_tcp_session(struct smb_vol *volume_info)
1593 struct TCP_Server_Info *tcp_ses = NULL;
1594 struct sockaddr_storage addr;
1595 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1596 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1599 memset(&addr, 0, sizeof(struct sockaddr_storage));
1601 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1603 if (volume_info->UNCip && volume_info->UNC) {
1604 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1606 strlen(volume_info->UNCip),
1609 /* we failed translating address */
1613 } else if (volume_info->UNCip) {
1614 /* BB using ip addr as tcp_ses name to connect to the
1616 cERROR(1, "Connecting to DFS root not implemented yet");
1619 } else /* which tcp_sess DFS root would we conect to */ {
1620 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1621 "unc=//192.168.1.100/public) specified");
1626 /* see if we already have a matching tcp_ses */
1627 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1631 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1637 rc = cifs_crypto_shash_allocate(tcp_ses);
1639 cERROR(1, "could not setup hash structures rc %d", rc);
1643 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1644 if (IS_ERR(tcp_ses->hostname)) {
1645 rc = PTR_ERR(tcp_ses->hostname);
1646 goto out_err_crypto_release;
1649 tcp_ses->noblocksnd = volume_info->noblocksnd;
1650 tcp_ses->noautotune = volume_info->noautotune;
1651 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1652 atomic_set(&tcp_ses->inFlight, 0);
1653 init_waitqueue_head(&tcp_ses->response_q);
1654 init_waitqueue_head(&tcp_ses->request_q);
1655 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1656 mutex_init(&tcp_ses->srv_mutex);
1657 memcpy(tcp_ses->workstation_RFC1001_name,
1658 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1659 memcpy(tcp_ses->server_RFC1001_name,
1660 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1661 tcp_ses->session_estab = false;
1662 tcp_ses->sequence_number = 0;
1663 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1664 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1667 * at this point we are the only ones with the pointer
1668 * to the struct since the kernel thread not created yet
1669 * no need to spinlock this init of tcpStatus or srv_count
1671 tcp_ses->tcpStatus = CifsNew;
1672 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1673 sizeof(tcp_ses->srcaddr));
1674 ++tcp_ses->srv_count;
1676 if (addr.ss_family == AF_INET6) {
1677 cFYI(1, "attempting ipv6 connect");
1678 /* BB should we allow ipv6 on port 139? */
1679 /* other OS never observed in Wild doing 139 with v6 */
1680 memcpy(&tcp_ses->dstaddr, sin_server6,
1681 sizeof(struct sockaddr_in6));
1683 memcpy(&tcp_ses->dstaddr, sin_server,
1684 sizeof(struct sockaddr_in));
1686 rc = ip_connect(tcp_ses);
1688 cERROR(1, "Error connecting to socket. Aborting operation");
1689 goto out_err_crypto_release;
1693 * since we're in a cifs function already, we know that
1694 * this will succeed. No need for try_module_get().
1696 __module_get(THIS_MODULE);
1697 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1699 if (IS_ERR(tcp_ses->tsk)) {
1700 rc = PTR_ERR(tcp_ses->tsk);
1701 cERROR(1, "error %d create cifsd thread", rc);
1702 module_put(THIS_MODULE);
1703 goto out_err_crypto_release;
1706 /* thread spawned, put it on the list */
1707 spin_lock(&cifs_tcp_ses_lock);
1708 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1709 spin_unlock(&cifs_tcp_ses_lock);
1711 cifs_fscache_get_client_cookie(tcp_ses);
1715 out_err_crypto_release:
1716 cifs_crypto_shash_release(tcp_ses);
1720 if (!IS_ERR(tcp_ses->hostname))
1721 kfree(tcp_ses->hostname);
1722 if (tcp_ses->ssocket)
1723 sock_release(tcp_ses->ssocket);
1729 static struct cifsSesInfo *
1730 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1732 struct cifsSesInfo *ses;
1734 spin_lock(&cifs_tcp_ses_lock);
1735 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1736 switch (server->secType) {
1738 if (vol->cred_uid != ses->cred_uid)
1742 /* anything else takes username/password */
1743 if (strncmp(ses->userName, vol->username,
1746 if (strlen(vol->username) != 0 &&
1747 ses->password != NULL &&
1748 strncmp(ses->password,
1749 vol->password ? vol->password : "",
1754 spin_unlock(&cifs_tcp_ses_lock);
1757 spin_unlock(&cifs_tcp_ses_lock);
1762 cifs_put_smb_ses(struct cifsSesInfo *ses)
1765 struct TCP_Server_Info *server = ses->server;
1767 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1768 spin_lock(&cifs_tcp_ses_lock);
1769 if (--ses->ses_count > 0) {
1770 spin_unlock(&cifs_tcp_ses_lock);
1774 list_del_init(&ses->smb_ses_list);
1775 spin_unlock(&cifs_tcp_ses_lock);
1777 if (ses->status == CifsGood) {
1779 CIFSSMBLogoff(xid, ses);
1783 cifs_put_tcp_session(server);
1786 static struct cifsSesInfo *
1787 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1789 int rc = -ENOMEM, xid;
1790 struct cifsSesInfo *ses;
1791 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1792 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1796 ses = cifs_find_smb_ses(server, volume_info);
1798 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1800 mutex_lock(&ses->session_mutex);
1801 rc = cifs_negotiate_protocol(xid, ses);
1803 mutex_unlock(&ses->session_mutex);
1804 /* problem -- put our ses reference */
1805 cifs_put_smb_ses(ses);
1809 if (ses->need_reconnect) {
1810 cFYI(1, "Session needs reconnect");
1811 rc = cifs_setup_session(xid, ses,
1812 volume_info->local_nls);
1814 mutex_unlock(&ses->session_mutex);
1815 /* problem -- put our reference */
1816 cifs_put_smb_ses(ses);
1821 mutex_unlock(&ses->session_mutex);
1823 /* existing SMB ses has a server reference already */
1824 cifs_put_tcp_session(server);
1829 cFYI(1, "Existing smb sess not found");
1830 ses = sesInfoAlloc();
1834 /* new SMB session uses our server ref */
1835 ses->server = server;
1836 if (server->dstaddr.ss_family == AF_INET6)
1837 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1839 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1841 if (volume_info->username)
1842 strncpy(ses->userName, volume_info->username,
1845 /* volume_info->password freed at unmount */
1846 if (volume_info->password) {
1847 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1851 if (volume_info->domainname) {
1852 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1853 if (!ses->domainName)
1856 ses->cred_uid = volume_info->cred_uid;
1857 ses->linux_uid = volume_info->linux_uid;
1858 ses->overrideSecFlg = volume_info->secFlg;
1860 mutex_lock(&ses->session_mutex);
1861 rc = cifs_negotiate_protocol(xid, ses);
1863 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1864 mutex_unlock(&ses->session_mutex);
1868 /* success, put it on the list */
1869 spin_lock(&cifs_tcp_ses_lock);
1870 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1871 spin_unlock(&cifs_tcp_ses_lock);
1882 static struct cifsTconInfo *
1883 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1885 struct list_head *tmp;
1886 struct cifsTconInfo *tcon;
1888 spin_lock(&cifs_tcp_ses_lock);
1889 list_for_each(tmp, &ses->tcon_list) {
1890 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1891 if (tcon->tidStatus == CifsExiting)
1893 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1897 spin_unlock(&cifs_tcp_ses_lock);
1900 spin_unlock(&cifs_tcp_ses_lock);
1905 cifs_put_tcon(struct cifsTconInfo *tcon)
1908 struct cifsSesInfo *ses = tcon->ses;
1910 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1911 spin_lock(&cifs_tcp_ses_lock);
1912 if (--tcon->tc_count > 0) {
1913 spin_unlock(&cifs_tcp_ses_lock);
1917 list_del_init(&tcon->tcon_list);
1918 spin_unlock(&cifs_tcp_ses_lock);
1921 CIFSSMBTDis(xid, tcon);
1924 cifs_fscache_release_super_cookie(tcon);
1926 cifs_put_smb_ses(ses);
1929 static struct cifsTconInfo *
1930 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1933 struct cifsTconInfo *tcon;
1935 tcon = cifs_find_tcon(ses, volume_info->UNC);
1937 cFYI(1, "Found match on UNC path");
1938 /* existing tcon already has a reference */
1939 cifs_put_smb_ses(ses);
1940 if (tcon->seal != volume_info->seal)
1941 cERROR(1, "transport encryption setting "
1942 "conflicts with existing tid");
1946 tcon = tconInfoAlloc();
1953 if (volume_info->password) {
1954 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
1955 if (!tcon->password) {
1961 if (strchr(volume_info->UNC + 3, '\\') == NULL
1962 && strchr(volume_info->UNC + 3, '/') == NULL) {
1963 cERROR(1, "Missing share name");
1968 /* BB Do we need to wrap session_mutex around
1969 * this TCon call and Unix SetFS as
1970 * we do on SessSetup and reconnect? */
1972 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
1974 cFYI(1, "CIFS Tcon rc = %d", rc);
1978 if (volume_info->nodfs) {
1979 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
1980 cFYI(1, "DFS disabled (%d)", tcon->Flags);
1982 tcon->seal = volume_info->seal;
1983 /* we can have only one retry value for a connection
1984 to a share so for resources mounted more than once
1985 to the same server share the last value passed in
1986 for the retry flag is used */
1987 tcon->retry = volume_info->retry;
1988 tcon->nocase = volume_info->nocase;
1989 tcon->local_lease = volume_info->local_lease;
1991 spin_lock(&cifs_tcp_ses_lock);
1992 list_add(&tcon->tcon_list, &ses->tcon_list);
1993 spin_unlock(&cifs_tcp_ses_lock);
1995 cifs_fscache_get_super_cookie(tcon);
2005 cifs_put_tlink(struct tcon_link *tlink)
2007 if (!tlink || IS_ERR(tlink))
2010 if (!atomic_dec_and_test(&tlink->tl_count) ||
2011 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2012 tlink->tl_time = jiffies;
2016 if (!IS_ERR(tlink_tcon(tlink)))
2017 cifs_put_tcon(tlink_tcon(tlink));
2023 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2024 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2025 struct dfs_info3_param **preferrals, int remap)
2030 *pnum_referrals = 0;
2033 if (pSesInfo->ipc_tid == 0) {
2034 temp_unc = kmalloc(2 /* for slashes */ +
2035 strnlen(pSesInfo->serverName,
2036 SERVER_NAME_LEN_WITH_NULL * 2)
2037 + 1 + 4 /* slash IPC$ */ + 2,
2039 if (temp_unc == NULL)
2043 strcpy(temp_unc + 2, pSesInfo->serverName);
2044 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2045 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2046 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2050 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2051 pnum_referrals, nls_codepage, remap);
2052 /* BB map targetUNCs to dfs_info3 structures, here or
2053 in CIFSGetDFSRefer BB */
2058 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2059 static struct lock_class_key cifs_key[2];
2060 static struct lock_class_key cifs_slock_key[2];
2063 cifs_reclassify_socket4(struct socket *sock)
2065 struct sock *sk = sock->sk;
2066 BUG_ON(sock_owned_by_user(sk));
2067 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2068 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2072 cifs_reclassify_socket6(struct socket *sock)
2074 struct sock *sk = sock->sk;
2075 BUG_ON(sock_owned_by_user(sk));
2076 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2077 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2081 cifs_reclassify_socket4(struct socket *sock)
2086 cifs_reclassify_socket6(struct socket *sock)
2091 /* See RFC1001 section 14 on representation of Netbios names */
2092 static void rfc1002mangle(char *target, char *source, unsigned int length)
2096 for (i = 0, j = 0; i < (length); i++) {
2097 /* mask a nibble at a time and encode */
2098 target[j] = 'A' + (0x0F & (source[i] >> 4));
2099 target[j+1] = 'A' + (0x0F & source[i]);
2106 bind_socket(struct TCP_Server_Info *server)
2109 if (server->srcaddr.ss_family != AF_UNSPEC) {
2110 /* Bind to the specified local IP address */
2111 struct socket *socket = server->ssocket;
2112 rc = socket->ops->bind(socket,
2113 (struct sockaddr *) &server->srcaddr,
2114 sizeof(server->srcaddr));
2116 struct sockaddr_in *saddr4;
2117 struct sockaddr_in6 *saddr6;
2118 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2119 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2120 if (saddr6->sin6_family == AF_INET6)
2122 "Failed to bind to: %pI6c, error: %d\n",
2123 &saddr6->sin6_addr, rc);
2126 "Failed to bind to: %pI4, error: %d\n",
2127 &saddr4->sin_addr.s_addr, rc);
2134 ip_rfc1001_connect(struct TCP_Server_Info *server)
2138 * some servers require RFC1001 sessinit before sending
2139 * negprot - BB check reconnection in case where second
2140 * sessinit is sent but no second negprot
2142 struct rfc1002_session_packet *ses_init_buf;
2143 struct smb_hdr *smb_buf;
2144 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2147 ses_init_buf->trailer.session_req.called_len = 32;
2149 if (server->server_RFC1001_name &&
2150 server->server_RFC1001_name[0] != 0)
2151 rfc1002mangle(ses_init_buf->trailer.
2152 session_req.called_name,
2153 server->server_RFC1001_name,
2154 RFC1001_NAME_LEN_WITH_NULL);
2156 rfc1002mangle(ses_init_buf->trailer.
2157 session_req.called_name,
2158 DEFAULT_CIFS_CALLED_NAME,
2159 RFC1001_NAME_LEN_WITH_NULL);
2161 ses_init_buf->trailer.session_req.calling_len = 32;
2164 * calling name ends in null (byte 16) from old smb
2167 if (server->workstation_RFC1001_name &&
2168 server->workstation_RFC1001_name[0] != 0)
2169 rfc1002mangle(ses_init_buf->trailer.
2170 session_req.calling_name,
2171 server->workstation_RFC1001_name,
2172 RFC1001_NAME_LEN_WITH_NULL);
2174 rfc1002mangle(ses_init_buf->trailer.
2175 session_req.calling_name,
2177 RFC1001_NAME_LEN_WITH_NULL);
2179 ses_init_buf->trailer.session_req.scope1 = 0;
2180 ses_init_buf->trailer.session_req.scope2 = 0;
2181 smb_buf = (struct smb_hdr *)ses_init_buf;
2183 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2184 smb_buf->smb_buf_length = 0x81000044;
2185 rc = smb_send(server, smb_buf, 0x44);
2186 kfree(ses_init_buf);
2188 * RFC1001 layer in at least one server
2189 * requires very short break before negprot
2190 * presumably because not expecting negprot
2191 * to follow so fast. This is a simple
2192 * solution that works without
2193 * complicating the code and causes no
2194 * significant slowing down on mount
2197 usleep_range(1000, 2000);
2200 * else the negprot may still work without this
2201 * even though malloc failed
2208 generic_ip_connect(struct TCP_Server_Info *server)
2211 unsigned short int sport;
2213 struct socket *socket = server->ssocket;
2214 struct sockaddr *saddr;
2216 saddr = (struct sockaddr *) &server->dstaddr;
2218 if (server->dstaddr.ss_family == AF_INET6) {
2219 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2220 slen = sizeof(struct sockaddr_in6);
2223 sport = ((struct sockaddr_in *) saddr)->sin_port;
2224 slen = sizeof(struct sockaddr_in);
2228 if (socket == NULL) {
2229 rc = sock_create_kern(sfamily, SOCK_STREAM,
2230 IPPROTO_TCP, &socket);
2232 cERROR(1, "Error %d creating socket", rc);
2233 server->ssocket = NULL;
2237 /* BB other socket options to set KEEPALIVE, NODELAY? */
2238 cFYI(1, "Socket created");
2239 server->ssocket = socket;
2240 socket->sk->sk_allocation = GFP_NOFS;
2241 if (sfamily == AF_INET6)
2242 cifs_reclassify_socket6(socket);
2244 cifs_reclassify_socket4(socket);
2247 rc = bind_socket(server);
2251 rc = socket->ops->connect(socket, saddr, slen, 0);
2253 cFYI(1, "Error %d connecting to server", rc);
2254 sock_release(socket);
2255 server->ssocket = NULL;
2260 * Eventually check for other socket options to change from
2261 * the default. sock_setsockopt not used because it expects
2264 socket->sk->sk_rcvtimeo = 7 * HZ;
2265 socket->sk->sk_sndtimeo = 5 * HZ;
2267 /* make the bufsizes depend on wsize/rsize and max requests */
2268 if (server->noautotune) {
2269 if (socket->sk->sk_sndbuf < (200 * 1024))
2270 socket->sk->sk_sndbuf = 200 * 1024;
2271 if (socket->sk->sk_rcvbuf < (140 * 1024))
2272 socket->sk->sk_rcvbuf = 140 * 1024;
2275 if (server->tcp_nodelay) {
2277 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2278 (char *)&val, sizeof(val));
2280 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2283 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2284 socket->sk->sk_sndbuf,
2285 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2287 if (sport == htons(RFC1001_PORT))
2288 rc = ip_rfc1001_connect(server);
2294 ip_connect(struct TCP_Server_Info *server)
2296 unsigned short int *sport;
2297 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2298 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2300 if (server->dstaddr.ss_family == AF_INET6)
2301 sport = &addr6->sin6_port;
2303 sport = &addr->sin_port;
2308 /* try with 445 port at first */
2309 *sport = htons(CIFS_PORT);
2311 rc = generic_ip_connect(server);
2315 /* if it failed, try with 139 port */
2316 *sport = htons(RFC1001_PORT);
2319 return generic_ip_connect(server);
2322 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2323 struct super_block *sb, struct smb_vol *vol_info)
2325 /* if we are reconnecting then should we check to see if
2326 * any requested capabilities changed locally e.g. via
2327 * remount but we can not do much about it here
2328 * if they have (even if we could detect it by the following)
2329 * Perhaps we could add a backpointer to array of sb from tcon
2330 * or if we change to make all sb to same share the same
2331 * sb as NFS - then we only have one backpointer to sb.
2332 * What if we wanted to mount the server share twice once with
2333 * and once without posixacls or posix paths? */
2334 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2336 if (vol_info && vol_info->no_linux_ext) {
2337 tcon->fsUnixInfo.Capability = 0;
2338 tcon->unix_ext = 0; /* Unix Extensions disabled */
2339 cFYI(1, "Linux protocol extensions disabled");
2341 } else if (vol_info)
2342 tcon->unix_ext = 1; /* Unix Extensions supported */
2344 if (tcon->unix_ext == 0) {
2345 cFYI(1, "Unix extensions disabled so not set on reconnect");
2349 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2350 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2352 /* check for reconnect case in which we do not
2353 want to change the mount behavior if we can avoid it */
2354 if (vol_info == NULL) {
2355 /* turn off POSIX ACL and PATHNAMES if not set
2356 originally at mount time */
2357 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2358 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2359 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2360 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2361 cERROR(1, "POSIXPATH support change");
2362 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2363 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2364 cERROR(1, "possible reconnect error");
2365 cERROR(1, "server disabled POSIX path support");
2369 cap &= CIFS_UNIX_CAP_MASK;
2370 if (vol_info && vol_info->no_psx_acl)
2371 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2372 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2373 cFYI(1, "negotiated posix acl support");
2375 sb->s_flags |= MS_POSIXACL;
2378 if (vol_info && vol_info->posix_paths == 0)
2379 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2380 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2381 cFYI(1, "negotiate posix pathnames");
2383 CIFS_SB(sb)->mnt_cifs_flags |=
2384 CIFS_MOUNT_POSIX_PATHS;
2387 /* We might be setting the path sep back to a different
2388 form if we are reconnecting and the server switched its
2389 posix path capability for this share */
2390 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2391 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2393 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2394 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2395 CIFS_SB(sb)->rsize = 127 * 1024;
2396 cFYI(DBG2, "larger reads not supported by srv");
2401 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2402 #ifdef CONFIG_CIFS_DEBUG2
2403 if (cap & CIFS_UNIX_FCNTL_CAP)
2404 cFYI(1, "FCNTL cap");
2405 if (cap & CIFS_UNIX_EXTATTR_CAP)
2406 cFYI(1, "EXTATTR cap");
2407 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2408 cFYI(1, "POSIX path cap");
2409 if (cap & CIFS_UNIX_XATTR_CAP)
2410 cFYI(1, "XATTR cap");
2411 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2412 cFYI(1, "POSIX ACL cap");
2413 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2414 cFYI(1, "very large read cap");
2415 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2416 cFYI(1, "very large write cap");
2417 #endif /* CIFS_DEBUG2 */
2418 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2419 if (vol_info == NULL) {
2420 cFYI(1, "resetting capabilities failed");
2422 cERROR(1, "Negotiating Unix capabilities "
2423 "with the server failed. Consider "
2424 "mounting with the Unix Extensions\n"
2425 "disabled, if problems are found, "
2426 "by specifying the nounix mount "
2434 convert_delimiter(char *path, char delim)
2447 for (i = 0; path[i] != '\0'; i++) {
2448 if (path[i] == old_delim)
2453 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2454 struct cifs_sb_info *cifs_sb)
2456 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2458 if (pvolume_info->rsize > CIFSMaxBufSize) {
2459 cERROR(1, "rsize %d too large, using MaxBufSize",
2460 pvolume_info->rsize);
2461 cifs_sb->rsize = CIFSMaxBufSize;
2462 } else if ((pvolume_info->rsize) &&
2463 (pvolume_info->rsize <= CIFSMaxBufSize))
2464 cifs_sb->rsize = pvolume_info->rsize;
2466 cifs_sb->rsize = CIFSMaxBufSize;
2468 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2469 cERROR(1, "wsize %d too large, using 4096 instead",
2470 pvolume_info->wsize);
2471 cifs_sb->wsize = 4096;
2472 } else if (pvolume_info->wsize)
2473 cifs_sb->wsize = pvolume_info->wsize;
2475 cifs_sb->wsize = min_t(const int,
2476 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2478 /* old default of CIFSMaxBufSize was too small now
2479 that SMB Write2 can send multiple pages in kvec.
2480 RFC1001 does not describe what happens when frame
2481 bigger than 128K is sent so use that as max in
2482 conjunction with 52K kvec constraint on arch with 4K
2485 if (cifs_sb->rsize < 2048) {
2486 cifs_sb->rsize = 2048;
2487 /* Windows ME may prefer this */
2488 cFYI(1, "readsize set to minimum: 2048");
2490 /* calculate prepath */
2491 cifs_sb->prepath = pvolume_info->prepath;
2492 if (cifs_sb->prepath) {
2493 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2494 /* we can not convert the / to \ in the path
2495 separators in the prefixpath yet because we do not
2496 know (until reset_cifs_unix_caps is called later)
2497 whether POSIX PATH CAP is available. We normalize
2498 the / to \ after reset_cifs_unix_caps is called */
2499 pvolume_info->prepath = NULL;
2501 cifs_sb->prepathlen = 0;
2502 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2503 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2504 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2505 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2506 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2507 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2509 cifs_sb->actimeo = pvolume_info->actimeo;
2511 if (pvolume_info->noperm)
2512 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2513 if (pvolume_info->setuids)
2514 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2515 if (pvolume_info->server_ino)
2516 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2517 if (pvolume_info->remap)
2518 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2519 if (pvolume_info->no_xattr)
2520 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2521 if (pvolume_info->sfu_emul)
2522 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2523 if (pvolume_info->nobrl)
2524 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2525 if (pvolume_info->nostrictsync)
2526 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2527 if (pvolume_info->mand_lock)
2528 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2529 if (pvolume_info->cifs_acl)
2530 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2531 if (pvolume_info->override_uid)
2532 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2533 if (pvolume_info->override_gid)
2534 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2535 if (pvolume_info->dynperm)
2536 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2537 if (pvolume_info->fsc)
2538 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2539 if (pvolume_info->multiuser)
2540 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2541 CIFS_MOUNT_NO_PERM);
2542 if (pvolume_info->direct_io) {
2543 cFYI(1, "mounting share using direct i/o");
2544 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2546 if (pvolume_info->mfsymlinks) {
2547 if (pvolume_info->sfu_emul) {
2548 cERROR(1, "mount option mfsymlinks ignored if sfu "
2549 "mount option is used");
2551 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2555 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2556 cERROR(1, "mount option dynperm ignored if cifsacl "
2557 "mount option supported");
2561 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2562 struct cifs_sb_info *cifs_sb, const char *full_path)
2565 FILE_ALL_INFO *pfile_info;
2567 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2568 if (pfile_info == NULL)
2571 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2572 0 /* not legacy */, cifs_sb->local_nls,
2573 cifs_sb->mnt_cifs_flags &
2574 CIFS_MOUNT_MAP_SPECIAL_CHR);
2580 cleanup_volume_info(struct smb_vol **pvolume_info)
2582 struct smb_vol *volume_info;
2584 if (!pvolume_info || !*pvolume_info)
2587 volume_info = *pvolume_info;
2588 kzfree(volume_info->password);
2589 kfree(volume_info->UNC);
2590 kfree(volume_info->prepath);
2592 *pvolume_info = NULL;
2596 #ifdef CONFIG_CIFS_DFS_UPCALL
2597 /* build_path_to_root returns full path to root when
2598 * we do not have an exiting connection (tcon) */
2600 build_unc_path_to_root(const struct smb_vol *volume_info,
2601 const struct cifs_sb_info *cifs_sb)
2605 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2606 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2607 if (full_path == NULL)
2608 return ERR_PTR(-ENOMEM);
2610 strncpy(full_path, volume_info->UNC, unc_len);
2611 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2613 for (i = 0; i < unc_len; i++) {
2614 if (full_path[i] == '\\')
2619 if (cifs_sb->prepathlen)
2620 strncpy(full_path + unc_len, cifs_sb->prepath,
2621 cifs_sb->prepathlen);
2623 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2629 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2630 char *mount_data_global, const char *devname)
2634 struct smb_vol *volume_info;
2635 struct cifsSesInfo *pSesInfo;
2636 struct cifsTconInfo *tcon;
2637 struct TCP_Server_Info *srvTcp;
2639 char *mount_data = mount_data_global;
2640 struct tcon_link *tlink;
2641 #ifdef CONFIG_CIFS_DFS_UPCALL
2642 struct dfs_info3_param *referrals = NULL;
2643 unsigned int num_referrals = 0;
2644 int referral_walks_count = 0;
2656 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2662 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2667 if (volume_info->nullauth) {
2668 cFYI(1, "null user");
2669 volume_info->username = "";
2670 } else if (volume_info->username) {
2671 /* BB fixme parse for domain name here */
2672 cFYI(1, "Username: %s", volume_info->username);
2674 cifserror("No username specified");
2675 /* In userspace mount helper we can get user name from alternate
2676 locations such as env variables and files on disk */
2681 /* this is needed for ASCII cp to Unicode converts */
2682 if (volume_info->iocharset == NULL) {
2683 /* load_nls_default cannot return null */
2684 volume_info->local_nls = load_nls_default();
2686 volume_info->local_nls = load_nls(volume_info->iocharset);
2687 if (volume_info->local_nls == NULL) {
2688 cERROR(1, "CIFS mount error: iocharset %s not found",
2689 volume_info->iocharset);
2694 cifs_sb->local_nls = volume_info->local_nls;
2696 /* get a reference to a tcp session */
2697 srvTcp = cifs_get_tcp_session(volume_info);
2698 if (IS_ERR(srvTcp)) {
2699 rc = PTR_ERR(srvTcp);
2703 /* get a reference to a SMB session */
2704 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2705 if (IS_ERR(pSesInfo)) {
2706 rc = PTR_ERR(pSesInfo);
2708 goto mount_fail_check;
2711 setup_cifs_sb(volume_info, cifs_sb);
2712 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2713 sb->s_maxbytes = MAX_LFS_FILESIZE;
2715 sb->s_maxbytes = MAX_NON_LFS;
2717 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2718 sb->s_time_gran = 100;
2720 /* search for existing tcon to this server share */
2721 tcon = cifs_get_tcon(pSesInfo, volume_info);
2725 goto remote_path_check;
2728 /* do not care if following two calls succeed - informational */
2730 CIFSSMBQFSDeviceInfo(xid, tcon);
2731 CIFSSMBQFSAttributeInfo(xid, tcon);
2734 /* tell server which Unix caps we support */
2735 if (tcon->ses->capabilities & CAP_UNIX)
2736 /* reset of caps checks mount to see if unix extensions
2737 disabled for just this mount */
2738 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2740 tcon->unix_ext = 0; /* server does not support them */
2742 /* convert forward to back slashes in prepath here if needed */
2743 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2744 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2746 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2747 cifs_sb->rsize = 1024 * 127;
2748 cFYI(DBG2, "no very large read support, rsize now 127K");
2750 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2751 cifs_sb->wsize = min(cifs_sb->wsize,
2752 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2753 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2754 cifs_sb->rsize = min(cifs_sb->rsize,
2755 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2758 /* check if a whole path (including prepath) is not remote */
2759 if (!rc && cifs_sb->prepathlen && tcon) {
2760 /* build_path_to_root works only when we have a valid tcon */
2761 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2762 if (full_path == NULL) {
2764 goto mount_fail_check;
2766 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2767 if (rc != 0 && rc != -EREMOTE) {
2769 goto mount_fail_check;
2774 /* get referral if needed */
2775 if (rc == -EREMOTE) {
2776 #ifdef CONFIG_CIFS_DFS_UPCALL
2777 if (referral_walks_count > MAX_NESTED_LINKS) {
2779 * BB: when we implement proper loop detection,
2780 * we will remove this check. But now we need it
2781 * to prevent an indefinite loop if 'DFS tree' is
2782 * misconfigured (i.e. has loops).
2785 goto mount_fail_check;
2787 /* convert forward to back slashes in prepath here if needed */
2788 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2789 convert_delimiter(cifs_sb->prepath,
2790 CIFS_DIR_SEP(cifs_sb));
2791 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2792 if (IS_ERR(full_path)) {
2793 rc = PTR_ERR(full_path);
2794 goto mount_fail_check;
2797 cFYI(1, "Getting referral for: %s", full_path);
2798 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2799 cifs_sb->local_nls, &num_referrals, &referrals,
2800 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2801 if (!rc && num_referrals > 0) {
2802 char *fake_devname = NULL;
2804 if (mount_data != mount_data_global)
2807 mount_data = cifs_compose_mount_options(
2808 cifs_sb->mountdata, full_path + 1,
2809 referrals, &fake_devname);
2811 free_dfs_info_array(referrals, num_referrals);
2812 kfree(fake_devname);
2815 if (IS_ERR(mount_data)) {
2816 rc = PTR_ERR(mount_data);
2818 goto mount_fail_check;
2822 cifs_put_tcon(tcon);
2824 cifs_put_smb_ses(pSesInfo);
2826 cleanup_volume_info(&volume_info);
2827 referral_walks_count++;
2829 goto try_mount_again;
2831 #else /* No DFS support, return error on mount */
2837 goto mount_fail_check;
2839 /* now, hang the tcon off of the superblock */
2840 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2841 if (tlink == NULL) {
2843 goto mount_fail_check;
2846 tlink->tl_uid = pSesInfo->linux_uid;
2847 tlink->tl_tcon = tcon;
2848 tlink->tl_time = jiffies;
2849 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2850 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2852 cifs_sb->master_tlink = tlink;
2853 spin_lock(&cifs_sb->tlink_tree_lock);
2854 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2855 spin_unlock(&cifs_sb->tlink_tree_lock);
2857 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2861 /* on error free sesinfo and tcon struct if needed */
2863 if (mount_data != mount_data_global)
2865 /* If find_unc succeeded then rc == 0 so we can not end */
2866 /* up accidently freeing someone elses tcon struct */
2868 cifs_put_tcon(tcon);
2870 cifs_put_smb_ses(pSesInfo);
2872 cifs_put_tcp_session(srvTcp);
2876 /* volume_info->password is freed above when existing session found
2877 (in which case it is not needed anymore) but when new sesion is created
2878 the password ptr is put in the new session structure (in which case the
2879 password will be freed at unmount time) */
2881 /* zero out password before freeing */
2882 cleanup_volume_info(&volume_info);
2888 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2889 const char *tree, struct cifsTconInfo *tcon,
2890 const struct nls_table *nls_codepage)
2892 struct smb_hdr *smb_buffer;
2893 struct smb_hdr *smb_buffer_response;
2896 unsigned char *bcc_ptr;
2898 int length, bytes_left;
2904 smb_buffer = cifs_buf_get();
2905 if (smb_buffer == NULL)
2908 smb_buffer_response = smb_buffer;
2910 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2911 NULL /*no tid */ , 4 /*wct */ );
2913 smb_buffer->Mid = GetNextMid(ses->server);
2914 smb_buffer->Uid = ses->Suid;
2915 pSMB = (TCONX_REQ *) smb_buffer;
2916 pSMBr = (TCONX_RSP *) smb_buffer_response;
2918 pSMB->AndXCommand = 0xFF;
2919 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2920 bcc_ptr = &pSMB->Password[0];
2921 if ((ses->server->secMode) & SECMODE_USER) {
2922 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
2923 *bcc_ptr = 0; /* password is null byte */
2924 bcc_ptr++; /* skip password */
2925 /* already aligned so no need to do it below */
2927 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
2928 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2929 specified as required (when that support is added to
2930 the vfs in the future) as only NTLM or the much
2931 weaker LANMAN (which we do not send by default) is accepted
2932 by Samba (not sure whether other servers allow
2933 NTLMv2 password here) */
2934 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2935 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
2936 (ses->server->secType == LANMAN))
2937 calc_lanman_hash(tcon->password, ses->server->cryptkey,
2938 ses->server->secMode &
2939 SECMODE_PW_ENCRYPT ? true : false,
2942 #endif /* CIFS_WEAK_PW_HASH */
2943 SMBNTencrypt(tcon->password, ses->server->cryptkey, bcc_ptr);
2945 bcc_ptr += CIFS_AUTH_RESP_SIZE;
2946 if (ses->capabilities & CAP_UNICODE) {
2947 /* must align unicode strings */
2948 *bcc_ptr = 0; /* null byte password */
2953 if (ses->server->secMode &
2954 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2955 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2957 if (ses->capabilities & CAP_STATUS32) {
2958 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2960 if (ses->capabilities & CAP_DFS) {
2961 smb_buffer->Flags2 |= SMBFLG2_DFS;
2963 if (ses->capabilities & CAP_UNICODE) {
2964 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2966 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2967 6 /* max utf8 char length in bytes */ *
2968 (/* server len*/ + 256 /* share len */), nls_codepage);
2969 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
2970 bcc_ptr += 2; /* skip trailing null */
2971 } else { /* ASCII */
2972 strcpy(bcc_ptr, tree);
2973 bcc_ptr += strlen(tree) + 1;
2975 strcpy(bcc_ptr, "?????");
2976 bcc_ptr += strlen("?????");
2978 count = bcc_ptr - &pSMB->Password[0];
2979 pSMB->hdr.smb_buf_length += count;
2980 pSMB->ByteCount = cpu_to_le16(count);
2982 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2985 /* above now done in SendReceive */
2986 if ((rc == 0) && (tcon != NULL)) {
2989 tcon->tidStatus = CifsGood;
2990 tcon->need_reconnect = false;
2991 tcon->tid = smb_buffer_response->Tid;
2992 bcc_ptr = pByteArea(smb_buffer_response);
2993 bytes_left = BCC(smb_buffer_response);
2994 length = strnlen(bcc_ptr, bytes_left - 2);
2995 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3001 /* skip service field (NB: this field is always ASCII) */
3003 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3004 (bcc_ptr[2] == 'C')) {
3005 cFYI(1, "IPC connection");
3008 } else if (length == 2) {
3009 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3010 /* the most common case */
3011 cFYI(1, "disk share connection");
3014 bcc_ptr += length + 1;
3015 bytes_left -= (length + 1);
3016 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3018 /* mostly informational -- no need to fail on error here */
3019 kfree(tcon->nativeFileSystem);
3020 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3021 bytes_left, is_unicode,
3024 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3026 if ((smb_buffer_response->WordCount == 3) ||
3027 (smb_buffer_response->WordCount == 7))
3028 /* field is in same location */
3029 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3032 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3033 } else if ((rc == 0) && tcon == NULL) {
3034 /* all we need to save for IPC$ connection */
3035 ses->ipc_tid = smb_buffer_response->Tid;
3038 cifs_buf_release(smb_buffer);
3043 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3045 struct rb_root *root = &cifs_sb->tlink_tree;
3046 struct rb_node *node;
3047 struct tcon_link *tlink;
3050 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3052 spin_lock(&cifs_sb->tlink_tree_lock);
3053 while ((node = rb_first(root))) {
3054 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3055 cifs_get_tlink(tlink);
3056 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3057 rb_erase(node, root);
3059 spin_unlock(&cifs_sb->tlink_tree_lock);
3060 cifs_put_tlink(tlink);
3061 spin_lock(&cifs_sb->tlink_tree_lock);
3063 spin_unlock(&cifs_sb->tlink_tree_lock);
3065 tmp = cifs_sb->prepath;
3066 cifs_sb->prepathlen = 0;
3067 cifs_sb->prepath = NULL;
3073 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3076 struct TCP_Server_Info *server = ses->server;
3078 /* only send once per connect */
3079 if (server->maxBuf != 0)
3082 rc = CIFSSMBNegotiate(xid, ses);
3083 if (rc == -EAGAIN) {
3084 /* retry only once on 1st time connection */
3085 rc = CIFSSMBNegotiate(xid, ses);
3090 spin_lock(&GlobalMid_Lock);
3091 if (server->tcpStatus != CifsExiting)
3092 server->tcpStatus = CifsGood;
3095 spin_unlock(&GlobalMid_Lock);
3103 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3104 struct nls_table *nls_info)
3107 struct TCP_Server_Info *server = ses->server;
3110 ses->capabilities = server->capabilities;
3111 if (linuxExtEnabled == 0)
3112 ses->capabilities &= (~CAP_UNIX);
3114 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3115 server->secMode, server->capabilities, server->timeAdj);
3117 rc = CIFS_SessSetup(xid, ses, nls_info);
3119 cERROR(1, "Send error in SessSetup = %d", rc);
3121 mutex_lock(&ses->server->srv_mutex);
3122 if (!server->session_estab) {
3123 server->session_key.response = ses->auth_key.response;
3124 server->session_key.len = ses->auth_key.len;
3125 server->sequence_number = 0x2;
3126 server->session_estab = true;
3127 ses->auth_key.response = NULL;
3129 mutex_unlock(&server->srv_mutex);
3131 cFYI(1, "CIFS Session Established successfully");
3132 spin_lock(&GlobalMid_Lock);
3133 ses->status = CifsGood;
3134 ses->need_reconnect = false;
3135 spin_unlock(&GlobalMid_Lock);
3138 kfree(ses->auth_key.response);
3139 ses->auth_key.response = NULL;
3140 ses->auth_key.len = 0;
3141 kfree(ses->ntlmssp);
3142 ses->ntlmssp = NULL;
3147 static struct cifsTconInfo *
3148 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3150 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3151 struct cifsSesInfo *ses;
3152 struct cifsTconInfo *tcon = NULL;
3153 struct smb_vol *vol_info;
3154 char username[MAX_USERNAME_SIZE + 1];
3156 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3157 if (vol_info == NULL) {
3158 tcon = ERR_PTR(-ENOMEM);
3162 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3163 vol_info->username = username;
3164 vol_info->local_nls = cifs_sb->local_nls;
3165 vol_info->linux_uid = fsuid;
3166 vol_info->cred_uid = fsuid;
3167 vol_info->UNC = master_tcon->treeName;
3168 vol_info->retry = master_tcon->retry;
3169 vol_info->nocase = master_tcon->nocase;
3170 vol_info->local_lease = master_tcon->local_lease;
3171 vol_info->no_linux_ext = !master_tcon->unix_ext;
3173 /* FIXME: allow for other secFlg settings */
3174 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3176 /* get a reference for the same TCP session */
3177 spin_lock(&cifs_tcp_ses_lock);
3178 ++master_tcon->ses->server->srv_count;
3179 spin_unlock(&cifs_tcp_ses_lock);
3181 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3183 tcon = (struct cifsTconInfo *)ses;
3184 cifs_put_tcp_session(master_tcon->ses->server);
3188 tcon = cifs_get_tcon(ses, vol_info);
3190 cifs_put_smb_ses(ses);
3194 if (ses->capabilities & CAP_UNIX)
3195 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3202 static inline struct tcon_link *
3203 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3205 return cifs_sb->master_tlink;
3208 struct cifsTconInfo *
3209 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3211 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3215 cifs_sb_tcon_pending_wait(void *unused)
3218 return signal_pending(current) ? -ERESTARTSYS : 0;
3221 /* find and return a tlink with given uid */
3222 static struct tcon_link *
3223 tlink_rb_search(struct rb_root *root, uid_t uid)
3225 struct rb_node *node = root->rb_node;
3226 struct tcon_link *tlink;
3229 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3231 if (tlink->tl_uid > uid)
3232 node = node->rb_left;
3233 else if (tlink->tl_uid < uid)
3234 node = node->rb_right;
3241 /* insert a tcon_link into the tree */
3243 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3245 struct rb_node **new = &(root->rb_node), *parent = NULL;
3246 struct tcon_link *tlink;
3249 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3252 if (tlink->tl_uid > new_tlink->tl_uid)
3253 new = &((*new)->rb_left);
3255 new = &((*new)->rb_right);
3258 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3259 rb_insert_color(&new_tlink->tl_rbnode, root);
3263 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3266 * If the superblock doesn't refer to a multiuser mount, then just return
3267 * the master tcon for the mount.
3269 * First, search the rbtree for an existing tcon for this fsuid. If one
3270 * exists, then check to see if it's pending construction. If it is then wait
3271 * for construction to complete. Once it's no longer pending, check to see if
3272 * it failed and either return an error or retry construction, depending on
3275 * If one doesn't exist then insert a new tcon_link struct into the tree and
3276 * try to construct a new one.
3279 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3282 uid_t fsuid = current_fsuid();
3283 struct tcon_link *tlink, *newtlink;
3285 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3286 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3288 spin_lock(&cifs_sb->tlink_tree_lock);
3289 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3291 cifs_get_tlink(tlink);
3292 spin_unlock(&cifs_sb->tlink_tree_lock);
3294 if (tlink == NULL) {
3295 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3296 if (newtlink == NULL)
3297 return ERR_PTR(-ENOMEM);
3298 newtlink->tl_uid = fsuid;
3299 newtlink->tl_tcon = ERR_PTR(-EACCES);
3300 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3301 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3302 cifs_get_tlink(newtlink);
3304 spin_lock(&cifs_sb->tlink_tree_lock);
3305 /* was one inserted after previous search? */
3306 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3308 cifs_get_tlink(tlink);
3309 spin_unlock(&cifs_sb->tlink_tree_lock);
3311 goto wait_for_construction;
3314 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3315 spin_unlock(&cifs_sb->tlink_tree_lock);
3317 wait_for_construction:
3318 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3319 cifs_sb_tcon_pending_wait,
3320 TASK_INTERRUPTIBLE);
3322 cifs_put_tlink(tlink);
3323 return ERR_PTR(ret);
3326 /* if it's good, return it */
3327 if (!IS_ERR(tlink->tl_tcon))
3330 /* return error if we tried this already recently */
3331 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3332 cifs_put_tlink(tlink);
3333 return ERR_PTR(-EACCES);
3336 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3337 goto wait_for_construction;
3340 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3341 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3342 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3344 if (IS_ERR(tlink->tl_tcon)) {
3345 cifs_put_tlink(tlink);
3346 return ERR_PTR(-EACCES);
3353 * periodic workqueue job that scans tcon_tree for a superblock and closes
3357 cifs_prune_tlinks(struct work_struct *work)
3359 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3361 struct rb_root *root = &cifs_sb->tlink_tree;
3362 struct rb_node *node = rb_first(root);
3363 struct rb_node *tmp;
3364 struct tcon_link *tlink;
3367 * Because we drop the spinlock in the loop in order to put the tlink
3368 * it's not guarded against removal of links from the tree. The only
3369 * places that remove entries from the tree are this function and
3370 * umounts. Because this function is non-reentrant and is canceled
3371 * before umount can proceed, this is safe.
3373 spin_lock(&cifs_sb->tlink_tree_lock);
3374 node = rb_first(root);
3375 while (node != NULL) {
3377 node = rb_next(tmp);
3378 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3380 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3381 atomic_read(&tlink->tl_count) != 0 ||
3382 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3385 cifs_get_tlink(tlink);
3386 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3387 rb_erase(tmp, root);
3389 spin_unlock(&cifs_sb->tlink_tree_lock);
3390 cifs_put_tlink(tlink);
3391 spin_lock(&cifs_sb->tlink_tree_lock);
3393 spin_unlock(&cifs_sb->tlink_tree_lock);
3395 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,