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"
54 #define RFC1001_PORT 139
56 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
59 extern mempool_t *cifs_req_poolp;
67 char *iocharset; /* local code page for mapping to and from Unicode */
68 char source_rfc1001_name[16]; /* netbios name of client */
69 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
83 bool no_psx_acl:1; /* set if posix acl support should be disabled */
85 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
86 bool server_ino:1; /* use inode numbers from server ie UniqueId */
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 */
105 bool sockopt_tcp_nodelay:1;
106 unsigned short int port;
108 struct nls_table *local_nls;
111 static int ipv4_connect(struct TCP_Server_Info *server);
112 static int ipv6_connect(struct TCP_Server_Info *server);
115 * cifs tcp session reconnection
117 * mark tcp session as reconnecting so temporarily locked
118 * mark all smb sessions as reconnecting for tcp session
119 * reconnect tcp session
120 * wake up waiters on reconnection? - (not needed currently)
123 cifs_reconnect(struct TCP_Server_Info *server)
126 struct list_head *tmp, *tmp2;
127 struct cifsSesInfo *ses;
128 struct cifsTconInfo *tcon;
129 struct mid_q_entry *mid_entry;
131 spin_lock(&GlobalMid_Lock);
132 if (server->tcpStatus == CifsExiting) {
133 /* the demux thread will exit normally
134 next time through the loop */
135 spin_unlock(&GlobalMid_Lock);
138 server->tcpStatus = CifsNeedReconnect;
139 spin_unlock(&GlobalMid_Lock);
142 cFYI(1, "Reconnecting tcp session");
144 /* before reconnecting the tcp session, mark the smb session (uid)
145 and the tid bad so they are not used until reconnected */
146 read_lock(&cifs_tcp_ses_lock);
147 list_for_each(tmp, &server->smb_ses_list) {
148 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
149 ses->need_reconnect = true;
151 list_for_each(tmp2, &ses->tcon_list) {
152 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
153 tcon->need_reconnect = true;
156 read_unlock(&cifs_tcp_ses_lock);
157 /* do not want to be sending data on a socket we are freeing */
158 mutex_lock(&server->srv_mutex);
159 if (server->ssocket) {
160 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
161 server->ssocket->flags);
162 kernel_sock_shutdown(server->ssocket, SHUT_WR);
163 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
164 server->ssocket->state,
165 server->ssocket->flags);
166 sock_release(server->ssocket);
167 server->ssocket = NULL;
170 spin_lock(&GlobalMid_Lock);
171 list_for_each(tmp, &server->pending_mid_q) {
172 mid_entry = list_entry(tmp, struct
175 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
176 /* Mark other intransit requests as needing
177 retry so we do not immediately mark the
178 session bad again (ie after we reconnect
179 below) as they timeout too */
180 mid_entry->midState = MID_RETRY_NEEDED;
183 spin_unlock(&GlobalMid_Lock);
184 mutex_unlock(&server->srv_mutex);
186 while ((server->tcpStatus != CifsExiting) &&
187 (server->tcpStatus != CifsGood)) {
189 if (server->addr.sockAddr6.sin6_family == AF_INET6)
190 rc = ipv6_connect(server);
192 rc = ipv4_connect(server);
194 cFYI(1, "reconnect error %d", rc);
197 atomic_inc(&tcpSesReconnectCount);
198 spin_lock(&GlobalMid_Lock);
199 if (server->tcpStatus != CifsExiting)
200 server->tcpStatus = CifsGood;
201 server->sequence_number = 0;
202 spin_unlock(&GlobalMid_Lock);
203 /* atomic_set(&server->inFlight,0);*/
204 wake_up(&server->response_q);
212 0 not a transact2, or all data present
213 >0 transact2 with that much data missing
214 -EINVAL = invalid transact2
217 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
219 struct smb_t2_rsp *pSMBt;
221 int data_in_this_rsp;
224 if (pSMB->Command != SMB_COM_TRANSACTION2)
227 /* check for plausible wct, bcc and t2 data and parm sizes */
228 /* check for parm and data offset going beyond end of smb */
229 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
230 cFYI(1, "invalid transact2 word count");
234 pSMBt = (struct smb_t2_rsp *)pSMB;
236 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
237 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
239 remaining = total_data_size - data_in_this_rsp;
243 else if (remaining < 0) {
244 cFYI(1, "total data %d smaller than data in frame %d",
245 total_data_size, data_in_this_rsp);
248 cFYI(1, "missing %d bytes from transact2, check next response",
250 if (total_data_size > maxBufSize) {
251 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
252 total_data_size, maxBufSize);
259 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
261 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
262 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
267 char *data_area_of_target;
268 char *data_area_of_buf2;
271 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
273 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
274 cFYI(1, "total data size of primary and secondary t2 differ");
277 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
279 remaining = total_data_size - total_in_buf;
284 if (remaining == 0) /* nothing to do, ignore */
287 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
288 if (remaining < total_in_buf2) {
289 cFYI(1, "transact2 2nd response contains too much data");
292 /* find end of first SMB data area */
293 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
294 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
295 /* validate target area */
297 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
298 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
300 data_area_of_target += total_in_buf;
302 /* copy second buffer into end of first buffer */
303 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
304 total_in_buf += total_in_buf2;
305 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
306 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
307 byte_count += total_in_buf2;
308 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
310 byte_count = pTargetSMB->smb_buf_length;
311 byte_count += total_in_buf2;
313 /* BB also add check that we are not beyond maximum buffer size */
315 pTargetSMB->smb_buf_length = byte_count;
317 if (remaining == total_in_buf2) {
318 cFYI(1, "found the last secondary response");
319 return 0; /* we are done */
320 } else /* more responses to go */
326 cifs_demultiplex_thread(struct TCP_Server_Info *server)
329 unsigned int pdu_length, total_read;
330 struct smb_hdr *smb_buffer = NULL;
331 struct smb_hdr *bigbuf = NULL;
332 struct smb_hdr *smallbuf = NULL;
333 struct msghdr smb_msg;
335 struct socket *csocket = server->ssocket;
336 struct list_head *tmp;
337 struct cifsSesInfo *ses;
338 struct task_struct *task_to_wake = NULL;
339 struct mid_q_entry *mid_entry;
341 bool isLargeBuf = false;
345 current->flags |= PF_MEMALLOC;
346 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
348 length = atomic_inc_return(&tcpSesAllocCount);
350 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
354 while (server->tcpStatus != CifsExiting) {
357 if (bigbuf == NULL) {
358 bigbuf = cifs_buf_get();
360 cERROR(1, "No memory for large SMB response");
362 /* retry will check if exiting */
365 } else if (isLargeBuf) {
366 /* we are reusing a dirty large buf, clear its start */
367 memset(bigbuf, 0, sizeof(struct smb_hdr));
370 if (smallbuf == NULL) {
371 smallbuf = cifs_small_buf_get();
373 cERROR(1, "No memory for SMB response");
375 /* retry will check if exiting */
378 /* beginning of smb buffer is cleared in our buf_get */
379 } else /* if existing small buf clear beginning */
380 memset(smallbuf, 0, sizeof(struct smb_hdr));
384 smb_buffer = smallbuf;
385 iov.iov_base = smb_buffer;
387 smb_msg.msg_control = NULL;
388 smb_msg.msg_controllen = 0;
389 pdu_length = 4; /* enough to get RFC1001 header */
392 kernel_recvmsg(csocket, &smb_msg,
393 &iov, 1, pdu_length, 0 /* BB other flags? */);
395 if (server->tcpStatus == CifsExiting) {
397 } else if (server->tcpStatus == CifsNeedReconnect) {
398 cFYI(1, "Reconnect after server stopped responding");
399 cifs_reconnect(server);
400 cFYI(1, "call to reconnect done");
401 csocket = server->ssocket;
403 } else if (length == -ERESTARTSYS ||
406 msleep(1); /* minimum sleep to prevent looping
407 allowing socket to clear and app threads to set
408 tcpStatus CifsNeedReconnect if server hung */
409 if (pdu_length < 4) {
410 iov.iov_base = (4 - pdu_length) +
412 iov.iov_len = pdu_length;
413 smb_msg.msg_control = NULL;
414 smb_msg.msg_controllen = 0;
418 } else if (length <= 0) {
419 cFYI(1, "Reconnect after unexpected peek error %d",
421 cifs_reconnect(server);
422 csocket = server->ssocket;
423 wake_up(&server->response_q);
425 } else if (length < pdu_length) {
426 cFYI(1, "requested %d bytes but only got %d bytes",
428 pdu_length -= length;
433 /* The right amount was read from socket - 4 bytes */
434 /* so we can now interpret the length field */
436 /* the first byte big endian of the length field,
437 is actually not part of the length but the type
438 with the most common, zero, as regular data */
439 temp = *((char *) smb_buffer);
441 /* Note that FC 1001 length is big endian on the wire,
442 but we convert it here so it is always manipulated
443 as host byte order */
444 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
445 smb_buffer->smb_buf_length = pdu_length;
447 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
449 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
451 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
452 cFYI(1, "Good RFC 1002 session rsp");
454 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
455 /* we get this from Windows 98 instead of
456 an error on SMB negprot response */
457 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
459 /* give server a second to clean up */
461 /* always try 445 first on reconnect since we get NACK
462 * on some if we ever connected to port 139 (the NACK
463 * is since we do not begin with RFC1001 session
466 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
467 cifs_reconnect(server);
468 csocket = server->ssocket;
469 wake_up(&server->response_q);
471 } else if (temp != (char) 0) {
472 cERROR(1, "Unknown RFC 1002 frame");
473 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
475 cifs_reconnect(server);
476 csocket = server->ssocket;
480 /* else we have an SMB response */
481 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
482 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
483 cERROR(1, "Invalid size SMB length %d pdu_length %d",
484 length, pdu_length+4);
485 cifs_reconnect(server);
486 csocket = server->ssocket;
487 wake_up(&server->response_q);
494 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
496 memcpy(bigbuf, smallbuf, 4);
500 iov.iov_base = 4 + (char *)smb_buffer;
501 iov.iov_len = pdu_length;
502 for (total_read = 0; total_read < pdu_length;
503 total_read += length) {
504 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
505 pdu_length - total_read, 0);
506 if (server->tcpStatus == CifsExiting) {
510 } else if (server->tcpStatus == CifsNeedReconnect) {
511 cifs_reconnect(server);
512 csocket = server->ssocket;
513 /* Reconnect wakes up rspns q */
514 /* Now we will reread sock */
517 } else if (length == -ERESTARTSYS ||
520 msleep(1); /* minimum sleep to prevent looping,
521 allowing socket to clear and app
522 threads to set tcpStatus
523 CifsNeedReconnect if server hung*/
526 } else if (length <= 0) {
527 cERROR(1, "Received no data, expecting %d",
528 pdu_length - total_read);
529 cifs_reconnect(server);
530 csocket = server->ssocket;
537 else if (reconnect == 1)
540 length += 4; /* account for rfc1002 hdr */
543 dump_smb(smb_buffer, length);
544 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
545 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
551 spin_lock(&GlobalMid_Lock);
552 list_for_each(tmp, &server->pending_mid_q) {
553 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
555 if ((mid_entry->mid == smb_buffer->Mid) &&
556 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
557 (mid_entry->command == smb_buffer->Command)) {
558 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
559 /* We have a multipart transact2 resp */
561 if (mid_entry->resp_buf) {
562 /* merge response - fix up 1st*/
563 if (coalesce_t2(smb_buffer,
564 mid_entry->resp_buf)) {
565 mid_entry->multiRsp =
569 /* all parts received */
570 mid_entry->multiEnd =
576 cERROR(1, "1st trans2 resp needs bigbuf");
577 /* BB maybe we can fix this up, switch
578 to already allocated large buffer? */
580 /* Have first buffer */
581 mid_entry->resp_buf =
583 mid_entry->largeBuf =
590 mid_entry->resp_buf = smb_buffer;
591 mid_entry->largeBuf = isLargeBuf;
593 task_to_wake = mid_entry->tsk;
594 mid_entry->midState = MID_RESPONSE_RECEIVED;
595 #ifdef CONFIG_CIFS_STATS2
596 mid_entry->when_received = jiffies;
598 /* so we do not time out requests to server
599 which is still responding (since server could
600 be busy but not dead) */
601 server->lstrp = jiffies;
605 spin_unlock(&GlobalMid_Lock);
607 /* Was previous buf put in mpx struct for multi-rsp? */
609 /* smb buffer will be freed by user thread */
615 wake_up_process(task_to_wake);
616 } else if (!is_valid_oplock_break(smb_buffer, server) &&
618 cERROR(1, "No task to wake, unknown frame received! "
619 "NumMids %d", midCount.counter);
620 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
621 sizeof(struct smb_hdr));
622 #ifdef CONFIG_CIFS_DEBUG2
623 cifs_dump_detail(smb_buffer);
624 cifs_dump_mids(server);
625 #endif /* CIFS_DEBUG2 */
628 } /* end while !EXITING */
630 /* take it off the list, if it's not already */
631 write_lock(&cifs_tcp_ses_lock);
632 list_del_init(&server->tcp_ses_list);
633 write_unlock(&cifs_tcp_ses_lock);
635 spin_lock(&GlobalMid_Lock);
636 server->tcpStatus = CifsExiting;
637 spin_unlock(&GlobalMid_Lock);
638 wake_up_all(&server->response_q);
640 /* check if we have blocked requests that need to free */
641 /* Note that cifs_max_pending is normally 50, but
642 can be set at module install time to as little as two */
643 spin_lock(&GlobalMid_Lock);
644 if (atomic_read(&server->inFlight) >= cifs_max_pending)
645 atomic_set(&server->inFlight, cifs_max_pending - 1);
646 /* We do not want to set the max_pending too low or we
647 could end up with the counter going negative */
648 spin_unlock(&GlobalMid_Lock);
649 /* Although there should not be any requests blocked on
650 this queue it can not hurt to be paranoid and try to wake up requests
651 that may haven been blocked when more than 50 at time were on the wire
652 to the same server - they now will see the session is in exit state
653 and get out of SendReceive. */
654 wake_up_all(&server->request_q);
655 /* give those requests time to exit */
658 if (server->ssocket) {
659 sock_release(csocket);
660 server->ssocket = NULL;
662 /* buffer usuallly freed in free_mid - need to free it here on exit */
663 cifs_buf_release(bigbuf);
664 if (smallbuf) /* no sense logging a debug message if NULL */
665 cifs_small_buf_release(smallbuf);
668 * BB: we shouldn't have to do any of this. It shouldn't be
669 * possible to exit from the thread with active SMB sessions
671 read_lock(&cifs_tcp_ses_lock);
672 if (list_empty(&server->pending_mid_q)) {
673 /* loop through server session structures attached to this and
675 list_for_each(tmp, &server->smb_ses_list) {
676 ses = list_entry(tmp, struct cifsSesInfo,
678 ses->status = CifsExiting;
681 read_unlock(&cifs_tcp_ses_lock);
683 /* although we can not zero the server struct pointer yet,
684 since there are active requests which may depnd on them,
685 mark the corresponding SMB sessions as exiting too */
686 list_for_each(tmp, &server->smb_ses_list) {
687 ses = list_entry(tmp, struct cifsSesInfo,
689 ses->status = CifsExiting;
692 spin_lock(&GlobalMid_Lock);
693 list_for_each(tmp, &server->pending_mid_q) {
694 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
695 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
696 cFYI(1, "Clearing Mid 0x%x - waking up ",
698 task_to_wake = mid_entry->tsk;
700 wake_up_process(task_to_wake);
703 spin_unlock(&GlobalMid_Lock);
704 read_unlock(&cifs_tcp_ses_lock);
705 /* 1/8th of sec is more than enough time for them to exit */
709 if (!list_empty(&server->pending_mid_q)) {
710 /* mpx threads have not exited yet give them
711 at least the smb send timeout time for long ops */
712 /* due to delays on oplock break requests, we need
713 to wait at least 45 seconds before giving up
714 on a request getting a response and going ahead
716 cFYI(1, "Wait for exit from demultiplex thread");
718 /* if threads still have not exited they are probably never
719 coming home not much else we can do but free the memory */
722 /* last chance to mark ses pointers invalid
723 if there are any pointing to this (e.g
724 if a crazy root user tried to kill cifsd
725 kernel thread explicitly this might happen) */
726 /* BB: This shouldn't be necessary, see above */
727 read_lock(&cifs_tcp_ses_lock);
728 list_for_each(tmp, &server->smb_ses_list) {
729 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
732 read_unlock(&cifs_tcp_ses_lock);
734 kfree(server->hostname);
735 task_to_wake = xchg(&server->tsk, NULL);
738 length = atomic_dec_return(&tcpSesAllocCount);
740 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
743 /* if server->tsk was NULL then wait for a signal before exiting */
745 set_current_state(TASK_INTERRUPTIBLE);
746 while (!signal_pending(current)) {
748 set_current_state(TASK_INTERRUPTIBLE);
750 set_current_state(TASK_RUNNING);
753 module_put_and_exit(0);
756 /* extract the host portion of the UNC string */
758 extract_hostname(const char *unc)
764 /* skip double chars at beginning of string */
765 /* BB: check validity of these bytes? */
768 /* delimiter between hostname and sharename is always '\\' now */
769 delim = strchr(src, '\\');
771 return ERR_PTR(-EINVAL);
774 dst = kmalloc((len + 1), GFP_KERNEL);
776 return ERR_PTR(-ENOMEM);
778 memcpy(dst, src, len);
785 cifs_parse_mount_options(char *options, const char *devname,
790 unsigned int temp_len, i, j;
792 short int override_uid = -1;
793 short int override_gid = -1;
794 bool uid_specified = false;
795 bool gid_specified = false;
800 if (Local_System_Name[0] != 0)
801 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
803 char *nodename = utsname()->nodename;
804 int n = strnlen(nodename, 15);
805 memset(vol->source_rfc1001_name, 0x20, 15);
806 for (i = 0; i < n; i++) {
807 /* does not have to be perfect mapping since field is
808 informational, only used for servers that do not support
809 port 445 and it can be overridden at mount time */
810 vol->source_rfc1001_name[i] = toupper(nodename[i]);
813 vol->source_rfc1001_name[15] = 0;
814 /* null target name indicates to use *SMBSERVR default called name
815 if we end up sending RFC1001 session initialize */
816 vol->target_rfc1001_name[0] = 0;
817 vol->cred_uid = current_uid();
818 vol->linux_uid = current_uid();
819 vol->linux_gid = current_gid();
821 /* default to only allowing write access to owner of the mount */
822 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
824 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
825 /* default is always to request posix paths. */
826 vol->posix_paths = 1;
827 /* default to using server inode numbers where available */
833 if (strncmp(options, "sep=", 4) == 0) {
834 if (options[4] != 0) {
835 separator[0] = options[4];
838 cFYI(1, "Null separator not allowed");
842 while ((data = strsep(&options, separator)) != NULL) {
845 if ((value = strchr(data, '=')) != NULL)
848 /* Have to parse this before we parse for "user" */
849 if (strnicmp(data, "user_xattr", 10) == 0) {
851 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
853 } else if (strnicmp(data, "user", 4) == 0) {
856 "CIFS: invalid or missing username\n");
857 return 1; /* needs_arg; */
858 } else if (!*value) {
859 /* null user, ie anonymous, authentication */
862 if (strnlen(value, 200) < 200) {
863 vol->username = value;
865 printk(KERN_WARNING "CIFS: username too long\n");
868 } else if (strnicmp(data, "pass", 4) == 0) {
870 vol->password = NULL;
872 } else if (value[0] == 0) {
873 /* check if string begins with double comma
874 since that would mean the password really
875 does start with a comma, and would not
876 indicate an empty string */
877 if (value[1] != separator[0]) {
878 vol->password = NULL;
882 temp_len = strlen(value);
883 /* removed password length check, NTLM passwords
884 can be arbitrarily long */
886 /* if comma in password, the string will be
887 prematurely null terminated. Commas in password are
888 specified across the cifs mount interface by a double
889 comma ie ,, and a comma used as in other cases ie ','
890 as a parameter delimiter/separator is single and due
891 to the strsep above is temporarily zeroed. */
893 /* NB: password legally can have multiple commas and
894 the only illegal character in a password is null */
896 if ((value[temp_len] == 0) &&
897 (value[temp_len+1] == separator[0])) {
899 value[temp_len] = separator[0];
900 temp_len += 2; /* move after second comma */
901 while (value[temp_len] != 0) {
902 if (value[temp_len] == separator[0]) {
903 if (value[temp_len+1] ==
905 /* skip second comma */
908 /* single comma indicating start
915 if (value[temp_len] == 0) {
919 /* point option to start of next parm */
920 options = value + temp_len + 1;
922 /* go from value to value + temp_len condensing
923 double commas to singles. Note that this ends up
924 allocating a few bytes too many, which is ok */
925 vol->password = kzalloc(temp_len, GFP_KERNEL);
926 if (vol->password == NULL) {
927 printk(KERN_WARNING "CIFS: no memory "
931 for (i = 0, j = 0; i < temp_len; i++, j++) {
932 vol->password[j] = value[i];
933 if (value[i] == separator[0]
934 && value[i+1] == separator[0]) {
935 /* skip second comma */
939 vol->password[j] = 0;
941 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
942 if (vol->password == NULL) {
943 printk(KERN_WARNING "CIFS: no memory "
947 strcpy(vol->password, value);
949 } else if (!strnicmp(data, "ip", 2) ||
950 !strnicmp(data, "addr", 4)) {
951 if (!value || !*value) {
953 } else if (strnlen(value, INET6_ADDRSTRLEN) <
957 printk(KERN_WARNING "CIFS: ip address "
961 } else if (strnicmp(data, "sec", 3) == 0) {
962 if (!value || !*value) {
963 cERROR(1, "no security value specified");
965 } else if (strnicmp(value, "krb5i", 5) == 0) {
966 vol->secFlg |= CIFSSEC_MAY_KRB5 |
968 } else if (strnicmp(value, "krb5p", 5) == 0) {
969 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
971 cERROR(1, "Krb5 cifs privacy not supported");
973 } else if (strnicmp(value, "krb5", 4) == 0) {
974 vol->secFlg |= CIFSSEC_MAY_KRB5;
975 #ifdef CONFIG_CIFS_EXPERIMENTAL
976 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
977 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
979 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
980 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
982 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
983 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
985 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
986 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
987 } else if (strnicmp(value, "ntlmi", 5) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_NTLM |
990 } else if (strnicmp(value, "ntlm", 4) == 0) {
991 /* ntlm is default so can be turned off too */
992 vol->secFlg |= CIFSSEC_MAY_NTLM;
993 } else if (strnicmp(value, "nontlm", 6) == 0) {
994 /* BB is there a better way to do this? */
995 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
996 #ifdef CONFIG_CIFS_WEAK_PW_HASH
997 } else if (strnicmp(value, "lanman", 6) == 0) {
998 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1000 } else if (strnicmp(value, "none", 4) == 0) {
1003 cERROR(1, "bad security option: %s", value);
1006 } else if ((strnicmp(data, "unc", 3) == 0)
1007 || (strnicmp(data, "target", 6) == 0)
1008 || (strnicmp(data, "path", 4) == 0)) {
1009 if (!value || !*value) {
1010 printk(KERN_WARNING "CIFS: invalid path to "
1011 "network resource\n");
1012 return 1; /* needs_arg; */
1014 if ((temp_len = strnlen(value, 300)) < 300) {
1015 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1016 if (vol->UNC == NULL)
1018 strcpy(vol->UNC, value);
1019 if (strncmp(vol->UNC, "//", 2) == 0) {
1022 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1024 "CIFS: UNC Path does not begin "
1025 "with // or \\\\ \n");
1029 printk(KERN_WARNING "CIFS: UNC name too long\n");
1032 } else if ((strnicmp(data, "domain", 3) == 0)
1033 || (strnicmp(data, "workgroup", 5) == 0)) {
1034 if (!value || !*value) {
1035 printk(KERN_WARNING "CIFS: invalid domain name\n");
1036 return 1; /* needs_arg; */
1038 /* BB are there cases in which a comma can be valid in
1039 a domain name and need special handling? */
1040 if (strnlen(value, 256) < 256) {
1041 vol->domainname = value;
1042 cFYI(1, "Domain name set");
1044 printk(KERN_WARNING "CIFS: domain name too "
1048 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1049 if (!value || !*value) {
1051 "CIFS: invalid path prefix\n");
1052 return 1; /* needs_argument */
1054 if ((temp_len = strnlen(value, 1024)) < 1024) {
1055 if (value[0] != '/')
1056 temp_len++; /* missing leading slash */
1057 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1058 if (vol->prepath == NULL)
1060 if (value[0] != '/') {
1061 vol->prepath[0] = '/';
1062 strcpy(vol->prepath+1, value);
1064 strcpy(vol->prepath, value);
1065 cFYI(1, "prefix path %s", vol->prepath);
1067 printk(KERN_WARNING "CIFS: prefix too long\n");
1070 } else if (strnicmp(data, "iocharset", 9) == 0) {
1071 if (!value || !*value) {
1072 printk(KERN_WARNING "CIFS: invalid iocharset "
1074 return 1; /* needs_arg; */
1076 if (strnlen(value, 65) < 65) {
1077 if (strnicmp(value, "default", 7))
1078 vol->iocharset = value;
1079 /* if iocharset not set then load_nls_default
1080 is used by caller */
1081 cFYI(1, "iocharset set to %s", value);
1083 printk(KERN_WARNING "CIFS: iocharset name "
1087 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1088 vol->linux_uid = simple_strtoul(value, &value, 0);
1089 uid_specified = true;
1090 } else if (!strnicmp(data, "forceuid", 8)) {
1092 } else if (!strnicmp(data, "noforceuid", 10)) {
1094 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1095 vol->linux_gid = simple_strtoul(value, &value, 0);
1096 gid_specified = true;
1097 } else if (!strnicmp(data, "forcegid", 8)) {
1099 } else if (!strnicmp(data, "noforcegid", 10)) {
1101 } else if (strnicmp(data, "file_mode", 4) == 0) {
1102 if (value && *value) {
1104 simple_strtoul(value, &value, 0);
1106 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1107 if (value && *value) {
1109 simple_strtoul(value, &value, 0);
1111 } else if (strnicmp(data, "dirmode", 4) == 0) {
1112 if (value && *value) {
1114 simple_strtoul(value, &value, 0);
1116 } else if (strnicmp(data, "port", 4) == 0) {
1117 if (value && *value) {
1119 simple_strtoul(value, &value, 0);
1121 } else if (strnicmp(data, "rsize", 5) == 0) {
1122 if (value && *value) {
1124 simple_strtoul(value, &value, 0);
1126 } else if (strnicmp(data, "wsize", 5) == 0) {
1127 if (value && *value) {
1129 simple_strtoul(value, &value, 0);
1131 } else if (strnicmp(data, "sockopt", 5) == 0) {
1132 if (!value || !*value) {
1133 cERROR(1, "no socket option specified");
1135 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1136 vol->sockopt_tcp_nodelay = 1;
1138 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1139 if (!value || !*value || (*value == ' ')) {
1140 cFYI(1, "invalid (empty) netbiosname");
1142 memset(vol->source_rfc1001_name, 0x20, 15);
1143 for (i = 0; i < 15; i++) {
1144 /* BB are there cases in which a comma can be
1145 valid in this workstation netbios name (and need
1146 special handling)? */
1148 /* We do not uppercase netbiosname for user */
1152 vol->source_rfc1001_name[i] =
1155 /* The string has 16th byte zero still from
1156 set at top of the function */
1157 if ((i == 15) && (value[i] != 0))
1158 printk(KERN_WARNING "CIFS: netbiosname"
1159 " longer than 15 truncated.\n");
1161 } else if (strnicmp(data, "servern", 7) == 0) {
1162 /* servernetbiosname specified override *SMBSERVER */
1163 if (!value || !*value || (*value == ' ')) {
1164 cFYI(1, "empty server netbiosname specified");
1166 /* last byte, type, is 0x20 for servr type */
1167 memset(vol->target_rfc1001_name, 0x20, 16);
1169 for (i = 0; i < 15; i++) {
1170 /* BB are there cases in which a comma can be
1171 valid in this workstation netbios name
1172 (and need special handling)? */
1174 /* user or mount helper must uppercase
1179 vol->target_rfc1001_name[i] =
1182 /* The string has 16th byte zero still from
1183 set at top of the function */
1184 if ((i == 15) && (value[i] != 0))
1185 printk(KERN_WARNING "CIFS: server net"
1186 "biosname longer than 15 truncated.\n");
1188 } else if (strnicmp(data, "credentials", 4) == 0) {
1190 } else if (strnicmp(data, "version", 3) == 0) {
1192 } else if (strnicmp(data, "guest", 5) == 0) {
1194 } else if (strnicmp(data, "rw", 2) == 0) {
1196 } else if (strnicmp(data, "ro", 2) == 0) {
1198 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1199 vol->noblocksnd = 1;
1200 } else if (strnicmp(data, "noautotune", 10) == 0) {
1201 vol->noautotune = 1;
1202 } else if ((strnicmp(data, "suid", 4) == 0) ||
1203 (strnicmp(data, "nosuid", 6) == 0) ||
1204 (strnicmp(data, "exec", 4) == 0) ||
1205 (strnicmp(data, "noexec", 6) == 0) ||
1206 (strnicmp(data, "nodev", 5) == 0) ||
1207 (strnicmp(data, "noauto", 6) == 0) ||
1208 (strnicmp(data, "dev", 3) == 0)) {
1209 /* The mount tool or mount.cifs helper (if present)
1210 uses these opts to set flags, and the flags are read
1211 by the kernel vfs layer before we get here (ie
1212 before read super) so there is no point trying to
1213 parse these options again and set anything and it
1214 is ok to just ignore them */
1216 } else if (strnicmp(data, "hard", 4) == 0) {
1218 } else if (strnicmp(data, "soft", 4) == 0) {
1220 } else if (strnicmp(data, "perm", 4) == 0) {
1222 } else if (strnicmp(data, "noperm", 6) == 0) {
1224 } else if (strnicmp(data, "mapchars", 8) == 0) {
1226 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1228 } else if (strnicmp(data, "sfu", 3) == 0) {
1230 } else if (strnicmp(data, "nosfu", 5) == 0) {
1232 } else if (strnicmp(data, "nodfs", 5) == 0) {
1234 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1235 vol->posix_paths = 1;
1236 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1237 vol->posix_paths = 0;
1238 } else if (strnicmp(data, "nounix", 6) == 0) {
1239 vol->no_linux_ext = 1;
1240 } else if (strnicmp(data, "nolinux", 7) == 0) {
1241 vol->no_linux_ext = 1;
1242 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1243 (strnicmp(data, "ignorecase", 10) == 0)) {
1245 } else if (strnicmp(data, "mand", 4) == 0) {
1247 } else if (strnicmp(data, "nomand", 6) == 0) {
1249 } else if (strnicmp(data, "_netdev", 7) == 0) {
1251 } else if (strnicmp(data, "brl", 3) == 0) {
1253 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1254 (strnicmp(data, "nolock", 6) == 0)) {
1256 /* turn off mandatory locking in mode
1257 if remote locking is turned off since the
1258 local vfs will do advisory */
1259 if (vol->file_mode ==
1260 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1261 vol->file_mode = S_IALLUGO;
1262 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1263 /* will take the shorter form "forcemand" as well */
1264 /* This mount option will force use of mandatory
1265 (DOS/Windows style) byte range locks, instead of
1266 using posix advisory byte range locks, even if the
1267 Unix extensions are available and posix locks would
1268 be supported otherwise. If Unix extensions are not
1269 negotiated this has no effect since mandatory locks
1270 would be used (mandatory locks is all that those
1271 those servers support) */
1273 } else if (strnicmp(data, "setuids", 7) == 0) {
1275 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1277 } else if (strnicmp(data, "dynperm", 7) == 0) {
1278 vol->dynperm = true;
1279 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1280 vol->dynperm = false;
1281 } else if (strnicmp(data, "nohard", 6) == 0) {
1283 } else if (strnicmp(data, "nosoft", 6) == 0) {
1285 } else if (strnicmp(data, "nointr", 6) == 0) {
1287 } else if (strnicmp(data, "intr", 4) == 0) {
1289 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1290 vol->nostrictsync = 1;
1291 } else if (strnicmp(data, "strictsync", 10) == 0) {
1292 vol->nostrictsync = 0;
1293 } else if (strnicmp(data, "serverino", 7) == 0) {
1294 vol->server_ino = 1;
1295 } else if (strnicmp(data, "noserverino", 9) == 0) {
1296 vol->server_ino = 0;
1297 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1299 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1301 } else if (strnicmp(data, "acl", 3) == 0) {
1302 vol->no_psx_acl = 0;
1303 } else if (strnicmp(data, "noacl", 5) == 0) {
1304 vol->no_psx_acl = 1;
1305 #ifdef CONFIG_CIFS_EXPERIMENTAL
1306 } else if (strnicmp(data, "locallease", 6) == 0) {
1307 vol->local_lease = 1;
1309 } else if (strnicmp(data, "sign", 4) == 0) {
1310 vol->secFlg |= CIFSSEC_MUST_SIGN;
1311 } else if (strnicmp(data, "seal", 4) == 0) {
1312 /* we do not do the following in secFlags because seal
1313 is a per tree connection (mount) not a per socket
1314 or per-smb connection option in the protocol */
1315 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1317 } else if (strnicmp(data, "direct", 6) == 0) {
1319 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1321 } else if (strnicmp(data, "noac", 4) == 0) {
1322 printk(KERN_WARNING "CIFS: Mount option noac not "
1323 "supported. Instead set "
1324 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1325 } else if (strnicmp(data, "fsc", 3) == 0) {
1328 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1331 if (vol->UNC == NULL) {
1332 if (devname == NULL) {
1333 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1337 if ((temp_len = strnlen(devname, 300)) < 300) {
1338 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1339 if (vol->UNC == NULL)
1341 strcpy(vol->UNC, devname);
1342 if (strncmp(vol->UNC, "//", 2) == 0) {
1345 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1346 printk(KERN_WARNING "CIFS: UNC Path does not "
1347 "begin with // or \\\\ \n");
1350 value = strpbrk(vol->UNC+2, "/\\");
1354 printk(KERN_WARNING "CIFS: UNC name too long\n");
1358 if (vol->UNCip == NULL)
1359 vol->UNCip = &vol->UNC[2];
1362 vol->override_uid = override_uid;
1363 else if (override_uid == 1)
1364 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1365 "specified with no uid= option.\n");
1368 vol->override_gid = override_gid;
1369 else if (override_gid == 1)
1370 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1371 "specified with no gid= option.\n");
1377 match_address(struct TCP_Server_Info *server, struct sockaddr *addr)
1379 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1380 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1382 switch (addr->sa_family) {
1384 if (addr4->sin_addr.s_addr !=
1385 server->addr.sockAddr.sin_addr.s_addr)
1387 if (addr4->sin_port &&
1388 addr4->sin_port != server->addr.sockAddr.sin_port)
1392 if (!ipv6_addr_equal(&addr6->sin6_addr,
1393 &server->addr.sockAddr6.sin6_addr))
1395 if (addr6->sin6_scope_id !=
1396 server->addr.sockAddr6.sin6_scope_id)
1398 if (addr6->sin6_port &&
1399 addr6->sin6_port != server->addr.sockAddr6.sin6_port)
1408 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1410 unsigned int secFlags;
1412 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1413 secFlags = vol->secFlg;
1415 secFlags = global_secflags | vol->secFlg;
1417 switch (server->secType) {
1419 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1423 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1427 if (!(secFlags & CIFSSEC_MAY_NTLM))
1431 if (!(secFlags & CIFSSEC_MAY_KRB5))
1435 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1439 /* shouldn't happen */
1443 /* now check if signing mode is acceptible */
1444 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1445 (server->secMode & SECMODE_SIGN_REQUIRED))
1447 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1449 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1455 static struct TCP_Server_Info *
1456 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1458 struct TCP_Server_Info *server;
1460 write_lock(&cifs_tcp_ses_lock);
1461 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1463 * the demux thread can exit on its own while still in CifsNew
1464 * so don't accept any sockets in that state. Since the
1465 * tcpStatus never changes back to CifsNew it's safe to check
1466 * for this without a lock.
1468 if (server->tcpStatus == CifsNew)
1471 if (!match_address(server, addr))
1474 if (!match_security(server, vol))
1477 ++server->srv_count;
1478 write_unlock(&cifs_tcp_ses_lock);
1479 cFYI(1, "Existing tcp session with server found");
1482 write_unlock(&cifs_tcp_ses_lock);
1487 cifs_put_tcp_session(struct TCP_Server_Info *server)
1489 struct task_struct *task;
1491 write_lock(&cifs_tcp_ses_lock);
1492 if (--server->srv_count > 0) {
1493 write_unlock(&cifs_tcp_ses_lock);
1497 list_del_init(&server->tcp_ses_list);
1498 write_unlock(&cifs_tcp_ses_lock);
1500 spin_lock(&GlobalMid_Lock);
1501 server->tcpStatus = CifsExiting;
1502 spin_unlock(&GlobalMid_Lock);
1504 cifs_fscache_release_client_cookie(server);
1506 task = xchg(&server->tsk, NULL);
1508 force_sig(SIGKILL, task);
1511 static struct TCP_Server_Info *
1512 cifs_get_tcp_session(struct smb_vol *volume_info)
1514 struct TCP_Server_Info *tcp_ses = NULL;
1515 struct sockaddr_storage addr;
1516 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1517 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1520 memset(&addr, 0, sizeof(struct sockaddr_storage));
1522 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1524 if (volume_info->UNCip && volume_info->UNC) {
1525 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1527 strlen(volume_info->UNCip),
1530 /* we failed translating address */
1534 } else if (volume_info->UNCip) {
1535 /* BB using ip addr as tcp_ses name to connect to the
1537 cERROR(1, "Connecting to DFS root not implemented yet");
1540 } else /* which tcp_sess DFS root would we conect to */ {
1541 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1542 "unc=//192.168.1.100/public) specified");
1547 /* see if we already have a matching tcp_ses */
1548 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1552 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1558 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1559 if (IS_ERR(tcp_ses->hostname)) {
1560 rc = PTR_ERR(tcp_ses->hostname);
1564 tcp_ses->noblocksnd = volume_info->noblocksnd;
1565 tcp_ses->noautotune = volume_info->noautotune;
1566 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1567 atomic_set(&tcp_ses->inFlight, 0);
1568 init_waitqueue_head(&tcp_ses->response_q);
1569 init_waitqueue_head(&tcp_ses->request_q);
1570 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1571 mutex_init(&tcp_ses->srv_mutex);
1572 memcpy(tcp_ses->workstation_RFC1001_name,
1573 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1574 memcpy(tcp_ses->server_RFC1001_name,
1575 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1576 tcp_ses->sequence_number = 0;
1577 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1578 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1581 * at this point we are the only ones with the pointer
1582 * to the struct since the kernel thread not created yet
1583 * no need to spinlock this init of tcpStatus or srv_count
1585 tcp_ses->tcpStatus = CifsNew;
1586 ++tcp_ses->srv_count;
1588 if (addr.ss_family == AF_INET6) {
1589 cFYI(1, "attempting ipv6 connect");
1590 /* BB should we allow ipv6 on port 139? */
1591 /* other OS never observed in Wild doing 139 with v6 */
1592 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1593 sizeof(struct sockaddr_in6));
1594 rc = ipv6_connect(tcp_ses);
1596 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1597 sizeof(struct sockaddr_in));
1598 rc = ipv4_connect(tcp_ses);
1601 cERROR(1, "Error connecting to socket. Aborting operation");
1606 * since we're in a cifs function already, we know that
1607 * this will succeed. No need for try_module_get().
1609 __module_get(THIS_MODULE);
1610 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1612 if (IS_ERR(tcp_ses->tsk)) {
1613 rc = PTR_ERR(tcp_ses->tsk);
1614 cERROR(1, "error %d create cifsd thread", rc);
1615 module_put(THIS_MODULE);
1619 /* thread spawned, put it on the list */
1620 write_lock(&cifs_tcp_ses_lock);
1621 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1622 write_unlock(&cifs_tcp_ses_lock);
1624 cifs_fscache_get_client_cookie(tcp_ses);
1630 if (!IS_ERR(tcp_ses->hostname))
1631 kfree(tcp_ses->hostname);
1632 if (tcp_ses->ssocket)
1633 sock_release(tcp_ses->ssocket);
1639 static struct cifsSesInfo *
1640 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1642 struct cifsSesInfo *ses;
1644 write_lock(&cifs_tcp_ses_lock);
1645 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1646 switch (server->secType) {
1648 if (vol->cred_uid != ses->cred_uid)
1652 /* anything else takes username/password */
1653 if (strncmp(ses->userName, vol->username,
1656 if (strlen(vol->username) != 0 &&
1657 ses->password != NULL &&
1658 strncmp(ses->password,
1659 vol->password ? vol->password : "",
1664 write_unlock(&cifs_tcp_ses_lock);
1667 write_unlock(&cifs_tcp_ses_lock);
1672 cifs_put_smb_ses(struct cifsSesInfo *ses)
1675 struct TCP_Server_Info *server = ses->server;
1677 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1678 write_lock(&cifs_tcp_ses_lock);
1679 if (--ses->ses_count > 0) {
1680 write_unlock(&cifs_tcp_ses_lock);
1684 list_del_init(&ses->smb_ses_list);
1685 write_unlock(&cifs_tcp_ses_lock);
1687 if (ses->status == CifsGood) {
1689 CIFSSMBLogoff(xid, ses);
1693 cifs_put_tcp_session(server);
1696 static struct cifsSesInfo *
1697 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1699 int rc = -ENOMEM, xid;
1700 struct cifsSesInfo *ses;
1704 ses = cifs_find_smb_ses(server, volume_info);
1706 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1708 /* existing SMB ses has a server reference already */
1709 cifs_put_tcp_session(server);
1711 mutex_lock(&ses->session_mutex);
1712 rc = cifs_negotiate_protocol(xid, ses);
1714 mutex_unlock(&ses->session_mutex);
1715 /* problem -- put our ses reference */
1716 cifs_put_smb_ses(ses);
1720 if (ses->need_reconnect) {
1721 cFYI(1, "Session needs reconnect");
1722 rc = cifs_setup_session(xid, ses,
1723 volume_info->local_nls);
1725 mutex_unlock(&ses->session_mutex);
1726 /* problem -- put our reference */
1727 cifs_put_smb_ses(ses);
1732 mutex_unlock(&ses->session_mutex);
1737 cFYI(1, "Existing smb sess not found");
1738 ses = sesInfoAlloc();
1742 /* new SMB session uses our server ref */
1743 ses->server = server;
1744 if (server->addr.sockAddr6.sin6_family == AF_INET6)
1745 sprintf(ses->serverName, "%pI6",
1746 &server->addr.sockAddr6.sin6_addr);
1748 sprintf(ses->serverName, "%pI4",
1749 &server->addr.sockAddr.sin_addr.s_addr);
1751 if (volume_info->username)
1752 strncpy(ses->userName, volume_info->username,
1755 /* volume_info->password freed at unmount */
1756 if (volume_info->password) {
1757 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1761 if (volume_info->domainname) {
1762 int len = strlen(volume_info->domainname);
1763 ses->domainName = kmalloc(len + 1, GFP_KERNEL);
1764 if (ses->domainName)
1765 strcpy(ses->domainName, volume_info->domainname);
1767 ses->cred_uid = volume_info->cred_uid;
1768 ses->linux_uid = volume_info->linux_uid;
1769 ses->overrideSecFlg = volume_info->secFlg;
1771 mutex_lock(&ses->session_mutex);
1772 rc = cifs_negotiate_protocol(xid, ses);
1774 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1775 mutex_unlock(&ses->session_mutex);
1779 /* success, put it on the list */
1780 write_lock(&cifs_tcp_ses_lock);
1781 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1782 write_unlock(&cifs_tcp_ses_lock);
1793 static struct cifsTconInfo *
1794 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1796 struct list_head *tmp;
1797 struct cifsTconInfo *tcon;
1799 write_lock(&cifs_tcp_ses_lock);
1800 list_for_each(tmp, &ses->tcon_list) {
1801 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1802 if (tcon->tidStatus == CifsExiting)
1804 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1808 write_unlock(&cifs_tcp_ses_lock);
1811 write_unlock(&cifs_tcp_ses_lock);
1816 cifs_put_tcon(struct cifsTconInfo *tcon)
1819 struct cifsSesInfo *ses = tcon->ses;
1821 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1822 write_lock(&cifs_tcp_ses_lock);
1823 if (--tcon->tc_count > 0) {
1824 write_unlock(&cifs_tcp_ses_lock);
1828 list_del_init(&tcon->tcon_list);
1829 write_unlock(&cifs_tcp_ses_lock);
1832 CIFSSMBTDis(xid, tcon);
1835 cifs_fscache_release_super_cookie(tcon);
1837 cifs_put_smb_ses(ses);
1840 static struct cifsTconInfo *
1841 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1844 struct cifsTconInfo *tcon;
1846 tcon = cifs_find_tcon(ses, volume_info->UNC);
1848 cFYI(1, "Found match on UNC path");
1849 /* existing tcon already has a reference */
1850 cifs_put_smb_ses(ses);
1851 if (tcon->seal != volume_info->seal)
1852 cERROR(1, "transport encryption setting "
1853 "conflicts with existing tid");
1857 tcon = tconInfoAlloc();
1864 if (volume_info->password) {
1865 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
1866 if (!tcon->password) {
1872 if (strchr(volume_info->UNC + 3, '\\') == NULL
1873 && strchr(volume_info->UNC + 3, '/') == NULL) {
1874 cERROR(1, "Missing share name");
1879 /* BB Do we need to wrap session_mutex around
1880 * this TCon call and Unix SetFS as
1881 * we do on SessSetup and reconnect? */
1883 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
1885 cFYI(1, "CIFS Tcon rc = %d", rc);
1889 if (volume_info->nodfs) {
1890 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
1891 cFYI(1, "DFS disabled (%d)", tcon->Flags);
1893 tcon->seal = volume_info->seal;
1894 /* we can have only one retry value for a connection
1895 to a share so for resources mounted more than once
1896 to the same server share the last value passed in
1897 for the retry flag is used */
1898 tcon->retry = volume_info->retry;
1899 tcon->nocase = volume_info->nocase;
1900 tcon->local_lease = volume_info->local_lease;
1902 write_lock(&cifs_tcp_ses_lock);
1903 list_add(&tcon->tcon_list, &ses->tcon_list);
1904 write_unlock(&cifs_tcp_ses_lock);
1906 cifs_fscache_get_super_cookie(tcon);
1917 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1918 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1919 struct dfs_info3_param **preferrals, int remap)
1924 *pnum_referrals = 0;
1927 if (pSesInfo->ipc_tid == 0) {
1928 temp_unc = kmalloc(2 /* for slashes */ +
1929 strnlen(pSesInfo->serverName,
1930 SERVER_NAME_LEN_WITH_NULL * 2)
1931 + 1 + 4 /* slash IPC$ */ + 2,
1933 if (temp_unc == NULL)
1937 strcpy(temp_unc + 2, pSesInfo->serverName);
1938 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1939 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1940 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
1944 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1945 pnum_referrals, nls_codepage, remap);
1946 /* BB map targetUNCs to dfs_info3 structures, here or
1947 in CIFSGetDFSRefer BB */
1952 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1953 static struct lock_class_key cifs_key[2];
1954 static struct lock_class_key cifs_slock_key[2];
1957 cifs_reclassify_socket4(struct socket *sock)
1959 struct sock *sk = sock->sk;
1960 BUG_ON(sock_owned_by_user(sk));
1961 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1962 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1966 cifs_reclassify_socket6(struct socket *sock)
1968 struct sock *sk = sock->sk;
1969 BUG_ON(sock_owned_by_user(sk));
1970 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1971 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1975 cifs_reclassify_socket4(struct socket *sock)
1980 cifs_reclassify_socket6(struct socket *sock)
1985 /* See RFC1001 section 14 on representation of Netbios names */
1986 static void rfc1002mangle(char *target, char *source, unsigned int length)
1990 for (i = 0, j = 0; i < (length); i++) {
1991 /* mask a nibble at a time and encode */
1992 target[j] = 'A' + (0x0F & (source[i] >> 4));
1993 target[j+1] = 'A' + (0x0F & source[i]);
2001 ipv4_connect(struct TCP_Server_Info *server)
2005 bool connected = false;
2006 __be16 orig_port = 0;
2007 struct socket *socket = server->ssocket;
2009 if (socket == NULL) {
2010 rc = sock_create_kern(PF_INET, SOCK_STREAM,
2011 IPPROTO_TCP, &socket);
2013 cERROR(1, "Error %d creating socket", rc);
2017 /* BB other socket options to set KEEPALIVE, NODELAY? */
2018 cFYI(1, "Socket created");
2019 server->ssocket = socket;
2020 socket->sk->sk_allocation = GFP_NOFS;
2021 cifs_reclassify_socket4(socket);
2024 /* user overrode default port */
2025 if (server->addr.sockAddr.sin_port) {
2026 rc = socket->ops->connect(socket, (struct sockaddr *)
2027 &server->addr.sockAddr,
2028 sizeof(struct sockaddr_in), 0);
2034 /* save original port so we can retry user specified port
2035 later if fall back ports fail this time */
2036 orig_port = server->addr.sockAddr.sin_port;
2038 /* do not retry on the same port we just failed on */
2039 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
2040 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
2041 rc = socket->ops->connect(socket,
2043 &server->addr.sockAddr,
2044 sizeof(struct sockaddr_in), 0);
2050 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
2051 rc = socket->ops->connect(socket, (struct sockaddr *)
2052 &server->addr.sockAddr,
2053 sizeof(struct sockaddr_in), 0);
2058 /* give up here - unless we want to retry on different
2059 protocol families some day */
2062 server->addr.sockAddr.sin_port = orig_port;
2063 cFYI(1, "Error %d connecting to server via ipv4", rc);
2064 sock_release(socket);
2065 server->ssocket = NULL;
2071 * Eventually check for other socket options to change from
2072 * the default. sock_setsockopt not used because it expects
2075 socket->sk->sk_rcvtimeo = 7 * HZ;
2076 socket->sk->sk_sndtimeo = 5 * HZ;
2078 /* make the bufsizes depend on wsize/rsize and max requests */
2079 if (server->noautotune) {
2080 if (socket->sk->sk_sndbuf < (200 * 1024))
2081 socket->sk->sk_sndbuf = 200 * 1024;
2082 if (socket->sk->sk_rcvbuf < (140 * 1024))
2083 socket->sk->sk_rcvbuf = 140 * 1024;
2086 if (server->tcp_nodelay) {
2088 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2089 (char *)&val, sizeof(val));
2091 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2094 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2095 socket->sk->sk_sndbuf,
2096 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2098 /* send RFC1001 sessinit */
2099 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
2100 /* some servers require RFC1001 sessinit before sending
2101 negprot - BB check reconnection in case where second
2102 sessinit is sent but no second negprot */
2103 struct rfc1002_session_packet *ses_init_buf;
2104 struct smb_hdr *smb_buf;
2105 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2108 ses_init_buf->trailer.session_req.called_len = 32;
2109 if (server->server_RFC1001_name &&
2110 server->server_RFC1001_name[0] != 0)
2111 rfc1002mangle(ses_init_buf->trailer.
2112 session_req.called_name,
2113 server->server_RFC1001_name,
2114 RFC1001_NAME_LEN_WITH_NULL);
2116 rfc1002mangle(ses_init_buf->trailer.
2117 session_req.called_name,
2118 DEFAULT_CIFS_CALLED_NAME,
2119 RFC1001_NAME_LEN_WITH_NULL);
2121 ses_init_buf->trailer.session_req.calling_len = 32;
2123 /* calling name ends in null (byte 16) from old smb
2125 if (server->workstation_RFC1001_name &&
2126 server->workstation_RFC1001_name[0] != 0)
2127 rfc1002mangle(ses_init_buf->trailer.
2128 session_req.calling_name,
2129 server->workstation_RFC1001_name,
2130 RFC1001_NAME_LEN_WITH_NULL);
2132 rfc1002mangle(ses_init_buf->trailer.
2133 session_req.calling_name,
2135 RFC1001_NAME_LEN_WITH_NULL);
2137 ses_init_buf->trailer.session_req.scope1 = 0;
2138 ses_init_buf->trailer.session_req.scope2 = 0;
2139 smb_buf = (struct smb_hdr *)ses_init_buf;
2140 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2141 smb_buf->smb_buf_length = 0x81000044;
2142 rc = smb_send(server, smb_buf, 0x44);
2143 kfree(ses_init_buf);
2144 msleep(1); /* RFC1001 layer in at least one server
2145 requires very short break before negprot
2146 presumably because not expecting negprot
2147 to follow so fast. This is a simple
2148 solution that works without
2149 complicating the code and causes no
2150 significant slowing down on mount
2151 for everyone else */
2153 /* else the negprot may still work without this
2154 even though malloc failed */
2162 ipv6_connect(struct TCP_Server_Info *server)
2166 bool connected = false;
2167 __be16 orig_port = 0;
2168 struct socket *socket = server->ssocket;
2170 if (socket == NULL) {
2171 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
2172 IPPROTO_TCP, &socket);
2174 cERROR(1, "Error %d creating ipv6 socket", rc);
2179 /* BB other socket options to set KEEPALIVE, NODELAY? */
2180 cFYI(1, "ipv6 Socket created");
2181 server->ssocket = socket;
2182 socket->sk->sk_allocation = GFP_NOFS;
2183 cifs_reclassify_socket6(socket);
2186 /* user overrode default port */
2187 if (server->addr.sockAddr6.sin6_port) {
2188 rc = socket->ops->connect(socket,
2189 (struct sockaddr *) &server->addr.sockAddr6,
2190 sizeof(struct sockaddr_in6), 0);
2196 /* save original port so we can retry user specified port
2197 later if fall back ports fail this time */
2199 orig_port = server->addr.sockAddr6.sin6_port;
2200 /* do not retry on the same port we just failed on */
2201 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
2202 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
2203 rc = socket->ops->connect(socket, (struct sockaddr *)
2204 &server->addr.sockAddr6,
2205 sizeof(struct sockaddr_in6), 0);
2211 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
2212 rc = socket->ops->connect(socket, (struct sockaddr *)
2213 &server->addr.sockAddr6,
2214 sizeof(struct sockaddr_in6), 0);
2219 /* give up here - unless we want to retry on different
2220 protocol families some day */
2223 server->addr.sockAddr6.sin6_port = orig_port;
2224 cFYI(1, "Error %d connecting to server via ipv6", rc);
2225 sock_release(socket);
2226 server->ssocket = NULL;
2231 * Eventually check for other socket options to change from
2232 * the default. sock_setsockopt not used because it expects
2235 socket->sk->sk_rcvtimeo = 7 * HZ;
2236 socket->sk->sk_sndtimeo = 5 * HZ;
2238 if (server->tcp_nodelay) {
2240 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2241 (char *)&val, sizeof(val));
2243 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2246 server->ssocket = socket;
2251 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2252 struct super_block *sb, struct smb_vol *vol_info)
2254 /* if we are reconnecting then should we check to see if
2255 * any requested capabilities changed locally e.g. via
2256 * remount but we can not do much about it here
2257 * if they have (even if we could detect it by the following)
2258 * Perhaps we could add a backpointer to array of sb from tcon
2259 * or if we change to make all sb to same share the same
2260 * sb as NFS - then we only have one backpointer to sb.
2261 * What if we wanted to mount the server share twice once with
2262 * and once without posixacls or posix paths? */
2263 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2265 if (vol_info && vol_info->no_linux_ext) {
2266 tcon->fsUnixInfo.Capability = 0;
2267 tcon->unix_ext = 0; /* Unix Extensions disabled */
2268 cFYI(1, "Linux protocol extensions disabled");
2270 } else if (vol_info)
2271 tcon->unix_ext = 1; /* Unix Extensions supported */
2273 if (tcon->unix_ext == 0) {
2274 cFYI(1, "Unix extensions disabled so not set on reconnect");
2278 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2279 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2281 /* check for reconnect case in which we do not
2282 want to change the mount behavior if we can avoid it */
2283 if (vol_info == NULL) {
2284 /* turn off POSIX ACL and PATHNAMES if not set
2285 originally at mount time */
2286 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2287 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2288 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2289 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2290 cERROR(1, "POSIXPATH support change");
2291 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2292 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2293 cERROR(1, "possible reconnect error");
2294 cERROR(1, "server disabled POSIX path support");
2298 cap &= CIFS_UNIX_CAP_MASK;
2299 if (vol_info && vol_info->no_psx_acl)
2300 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2301 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2302 cFYI(1, "negotiated posix acl support");
2304 sb->s_flags |= MS_POSIXACL;
2307 if (vol_info && vol_info->posix_paths == 0)
2308 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2309 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2310 cFYI(1, "negotiate posix pathnames");
2312 CIFS_SB(sb)->mnt_cifs_flags |=
2313 CIFS_MOUNT_POSIX_PATHS;
2316 /* We might be setting the path sep back to a different
2317 form if we are reconnecting and the server switched its
2318 posix path capability for this share */
2319 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2320 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2322 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2323 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2324 CIFS_SB(sb)->rsize = 127 * 1024;
2325 cFYI(DBG2, "larger reads not supported by srv");
2330 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2331 #ifdef CONFIG_CIFS_DEBUG2
2332 if (cap & CIFS_UNIX_FCNTL_CAP)
2333 cFYI(1, "FCNTL cap");
2334 if (cap & CIFS_UNIX_EXTATTR_CAP)
2335 cFYI(1, "EXTATTR cap");
2336 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2337 cFYI(1, "POSIX path cap");
2338 if (cap & CIFS_UNIX_XATTR_CAP)
2339 cFYI(1, "XATTR cap");
2340 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2341 cFYI(1, "POSIX ACL cap");
2342 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2343 cFYI(1, "very large read cap");
2344 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2345 cFYI(1, "very large write cap");
2346 #endif /* CIFS_DEBUG2 */
2347 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2348 if (vol_info == NULL) {
2349 cFYI(1, "resetting capabilities failed");
2351 cERROR(1, "Negotiating Unix capabilities "
2352 "with the server failed. Consider "
2353 "mounting with the Unix Extensions\n"
2354 "disabled, if problems are found, "
2355 "by specifying the nounix mount "
2363 convert_delimiter(char *path, char delim)
2376 for (i = 0; path[i] != '\0'; i++) {
2377 if (path[i] == old_delim)
2382 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2383 struct cifs_sb_info *cifs_sb)
2385 if (pvolume_info->rsize > CIFSMaxBufSize) {
2386 cERROR(1, "rsize %d too large, using MaxBufSize",
2387 pvolume_info->rsize);
2388 cifs_sb->rsize = CIFSMaxBufSize;
2389 } else if ((pvolume_info->rsize) &&
2390 (pvolume_info->rsize <= CIFSMaxBufSize))
2391 cifs_sb->rsize = pvolume_info->rsize;
2393 cifs_sb->rsize = CIFSMaxBufSize;
2395 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2396 cERROR(1, "wsize %d too large, using 4096 instead",
2397 pvolume_info->wsize);
2398 cifs_sb->wsize = 4096;
2399 } else if (pvolume_info->wsize)
2400 cifs_sb->wsize = pvolume_info->wsize;
2402 cifs_sb->wsize = min_t(const int,
2403 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2405 /* old default of CIFSMaxBufSize was too small now
2406 that SMB Write2 can send multiple pages in kvec.
2407 RFC1001 does not describe what happens when frame
2408 bigger than 128K is sent so use that as max in
2409 conjunction with 52K kvec constraint on arch with 4K
2412 if (cifs_sb->rsize < 2048) {
2413 cifs_sb->rsize = 2048;
2414 /* Windows ME may prefer this */
2415 cFYI(1, "readsize set to minimum: 2048");
2417 /* calculate prepath */
2418 cifs_sb->prepath = pvolume_info->prepath;
2419 if (cifs_sb->prepath) {
2420 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2421 /* we can not convert the / to \ in the path
2422 separators in the prefixpath yet because we do not
2423 know (until reset_cifs_unix_caps is called later)
2424 whether POSIX PATH CAP is available. We normalize
2425 the / to \ after reset_cifs_unix_caps is called */
2426 pvolume_info->prepath = NULL;
2428 cifs_sb->prepathlen = 0;
2429 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2430 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2431 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2432 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2433 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2434 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2436 if (pvolume_info->noperm)
2437 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2438 if (pvolume_info->setuids)
2439 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2440 if (pvolume_info->server_ino)
2441 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2442 if (pvolume_info->remap)
2443 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2444 if (pvolume_info->no_xattr)
2445 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2446 if (pvolume_info->sfu_emul)
2447 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2448 if (pvolume_info->nobrl)
2449 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2450 if (pvolume_info->nostrictsync)
2451 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2452 if (pvolume_info->mand_lock)
2453 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2454 if (pvolume_info->cifs_acl)
2455 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2456 if (pvolume_info->override_uid)
2457 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2458 if (pvolume_info->override_gid)
2459 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2460 if (pvolume_info->dynperm)
2461 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2462 if (pvolume_info->fsc)
2463 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2464 if (pvolume_info->direct_io) {
2465 cFYI(1, "mounting share using direct i/o");
2466 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2469 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2470 cERROR(1, "mount option dynperm ignored if cifsacl "
2471 "mount option supported");
2475 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2476 struct cifs_sb_info *cifs_sb, const char *full_path)
2479 FILE_ALL_INFO *pfile_info;
2481 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2482 if (pfile_info == NULL)
2485 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2486 0 /* not legacy */, cifs_sb->local_nls,
2487 cifs_sb->mnt_cifs_flags &
2488 CIFS_MOUNT_MAP_SPECIAL_CHR);
2494 cleanup_volume_info(struct smb_vol **pvolume_info)
2496 struct smb_vol *volume_info;
2498 if (!pvolume_info || !*pvolume_info)
2501 volume_info = *pvolume_info;
2502 kzfree(volume_info->password);
2503 kfree(volume_info->UNC);
2504 kfree(volume_info->prepath);
2506 *pvolume_info = NULL;
2510 #ifdef CONFIG_CIFS_DFS_UPCALL
2511 /* build_path_to_root returns full path to root when
2512 * we do not have an exiting connection (tcon) */
2514 build_unc_path_to_root(const struct smb_vol *volume_info,
2515 const struct cifs_sb_info *cifs_sb)
2519 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2520 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2521 if (full_path == NULL)
2522 return ERR_PTR(-ENOMEM);
2524 strncpy(full_path, volume_info->UNC, unc_len);
2525 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2527 for (i = 0; i < unc_len; i++) {
2528 if (full_path[i] == '\\')
2533 if (cifs_sb->prepathlen)
2534 strncpy(full_path + unc_len, cifs_sb->prepath,
2535 cifs_sb->prepathlen);
2537 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2543 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2544 char *mount_data_global, const char *devname)
2548 struct smb_vol *volume_info;
2549 struct cifsSesInfo *pSesInfo;
2550 struct cifsTconInfo *tcon;
2551 struct TCP_Server_Info *srvTcp;
2553 char *mount_data = mount_data_global;
2554 #ifdef CONFIG_CIFS_DFS_UPCALL
2555 struct dfs_info3_param *referrals = NULL;
2556 unsigned int num_referrals = 0;
2557 int referral_walks_count = 0;
2568 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2574 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2579 if (volume_info->nullauth) {
2580 cFYI(1, "null user");
2581 volume_info->username = "";
2582 } else if (volume_info->username) {
2583 /* BB fixme parse for domain name here */
2584 cFYI(1, "Username: %s", volume_info->username);
2586 cifserror("No username specified");
2587 /* In userspace mount helper we can get user name from alternate
2588 locations such as env variables and files on disk */
2593 /* this is needed for ASCII cp to Unicode converts */
2594 if (volume_info->iocharset == NULL) {
2595 /* load_nls_default cannot return null */
2596 volume_info->local_nls = load_nls_default();
2598 volume_info->local_nls = load_nls(volume_info->iocharset);
2599 if (volume_info->local_nls == NULL) {
2600 cERROR(1, "CIFS mount error: iocharset %s not found",
2601 volume_info->iocharset);
2606 cifs_sb->local_nls = volume_info->local_nls;
2608 /* get a reference to a tcp session */
2609 srvTcp = cifs_get_tcp_session(volume_info);
2610 if (IS_ERR(srvTcp)) {
2611 rc = PTR_ERR(srvTcp);
2615 /* get a reference to a SMB session */
2616 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2617 if (IS_ERR(pSesInfo)) {
2618 rc = PTR_ERR(pSesInfo);
2620 goto mount_fail_check;
2623 setup_cifs_sb(volume_info, cifs_sb);
2624 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2625 sb->s_maxbytes = MAX_LFS_FILESIZE;
2627 sb->s_maxbytes = MAX_NON_LFS;
2629 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2630 sb->s_time_gran = 100;
2632 /* search for existing tcon to this server share */
2633 tcon = cifs_get_tcon(pSesInfo, volume_info);
2637 goto remote_path_check;
2640 cifs_sb->tcon = tcon;
2642 /* do not care if following two calls succeed - informational */
2644 CIFSSMBQFSDeviceInfo(xid, tcon);
2645 CIFSSMBQFSAttributeInfo(xid, tcon);
2648 /* tell server which Unix caps we support */
2649 if (tcon->ses->capabilities & CAP_UNIX)
2650 /* reset of caps checks mount to see if unix extensions
2651 disabled for just this mount */
2652 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2654 tcon->unix_ext = 0; /* server does not support them */
2656 /* convert forward to back slashes in prepath here if needed */
2657 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2658 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2660 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2661 cifs_sb->rsize = 1024 * 127;
2662 cFYI(DBG2, "no very large read support, rsize now 127K");
2664 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2665 cifs_sb->wsize = min(cifs_sb->wsize,
2666 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2667 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2668 cifs_sb->rsize = min(cifs_sb->rsize,
2669 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2672 /* check if a whole path (including prepath) is not remote */
2673 if (!rc && cifs_sb->prepathlen && tcon) {
2674 /* build_path_to_root works only when we have a valid tcon */
2675 full_path = cifs_build_path_to_root(cifs_sb);
2676 if (full_path == NULL) {
2678 goto mount_fail_check;
2680 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2681 if (rc != -EREMOTE) {
2683 goto mount_fail_check;
2688 /* get referral if needed */
2689 if (rc == -EREMOTE) {
2690 #ifdef CONFIG_CIFS_DFS_UPCALL
2691 if (referral_walks_count > MAX_NESTED_LINKS) {
2693 * BB: when we implement proper loop detection,
2694 * we will remove this check. But now we need it
2695 * to prevent an indefinite loop if 'DFS tree' is
2696 * misconfigured (i.e. has loops).
2699 goto mount_fail_check;
2701 /* convert forward to back slashes in prepath here if needed */
2702 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2703 convert_delimiter(cifs_sb->prepath,
2704 CIFS_DIR_SEP(cifs_sb));
2705 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2706 if (IS_ERR(full_path)) {
2707 rc = PTR_ERR(full_path);
2708 goto mount_fail_check;
2711 cFYI(1, "Getting referral for: %s", full_path);
2712 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2713 cifs_sb->local_nls, &num_referrals, &referrals,
2714 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2715 if (!rc && num_referrals > 0) {
2716 char *fake_devname = NULL;
2718 if (mount_data != mount_data_global)
2721 mount_data = cifs_compose_mount_options(
2722 cifs_sb->mountdata, full_path + 1,
2723 referrals, &fake_devname);
2725 free_dfs_info_array(referrals, num_referrals);
2726 kfree(fake_devname);
2729 if (IS_ERR(mount_data)) {
2730 rc = PTR_ERR(mount_data);
2732 goto mount_fail_check;
2736 cifs_put_tcon(tcon);
2738 cifs_put_smb_ses(pSesInfo);
2740 cleanup_volume_info(&volume_info);
2741 referral_walks_count++;
2743 goto try_mount_again;
2745 #else /* No DFS support, return error on mount */
2751 /* on error free sesinfo and tcon struct if needed */
2753 if (mount_data != mount_data_global)
2755 /* If find_unc succeeded then rc == 0 so we can not end */
2756 /* up accidently freeing someone elses tcon struct */
2758 cifs_put_tcon(tcon);
2760 cifs_put_smb_ses(pSesInfo);
2762 cifs_put_tcp_session(srvTcp);
2766 /* volume_info->password is freed above when existing session found
2767 (in which case it is not needed anymore) but when new sesion is created
2768 the password ptr is put in the new session structure (in which case the
2769 password will be freed at unmount time) */
2771 /* zero out password before freeing */
2772 cleanup_volume_info(&volume_info);
2778 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2779 const char *tree, struct cifsTconInfo *tcon,
2780 const struct nls_table *nls_codepage)
2782 struct smb_hdr *smb_buffer;
2783 struct smb_hdr *smb_buffer_response;
2786 unsigned char *bcc_ptr;
2788 int length, bytes_left;
2794 smb_buffer = cifs_buf_get();
2795 if (smb_buffer == NULL)
2798 smb_buffer_response = smb_buffer;
2800 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2801 NULL /*no tid */ , 4 /*wct */ );
2803 smb_buffer->Mid = GetNextMid(ses->server);
2804 smb_buffer->Uid = ses->Suid;
2805 pSMB = (TCONX_REQ *) smb_buffer;
2806 pSMBr = (TCONX_RSP *) smb_buffer_response;
2808 pSMB->AndXCommand = 0xFF;
2809 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2810 bcc_ptr = &pSMB->Password[0];
2811 if ((ses->server->secMode) & SECMODE_USER) {
2812 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
2813 *bcc_ptr = 0; /* password is null byte */
2814 bcc_ptr++; /* skip password */
2815 /* already aligned so no need to do it below */
2817 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
2818 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2819 specified as required (when that support is added to
2820 the vfs in the future) as only NTLM or the much
2821 weaker LANMAN (which we do not send by default) is accepted
2822 by Samba (not sure whether other servers allow
2823 NTLMv2 password here) */
2824 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2825 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
2826 (ses->server->secType == LANMAN))
2827 calc_lanman_hash(tcon->password, ses->server->cryptKey,
2828 ses->server->secMode &
2829 SECMODE_PW_ENCRYPT ? true : false,
2832 #endif /* CIFS_WEAK_PW_HASH */
2833 SMBNTencrypt(tcon->password, ses->server->cryptKey,
2836 bcc_ptr += CIFS_SESS_KEY_SIZE;
2837 if (ses->capabilities & CAP_UNICODE) {
2838 /* must align unicode strings */
2839 *bcc_ptr = 0; /* null byte password */
2844 if (ses->server->secMode &
2845 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2846 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2848 if (ses->capabilities & CAP_STATUS32) {
2849 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2851 if (ses->capabilities & CAP_DFS) {
2852 smb_buffer->Flags2 |= SMBFLG2_DFS;
2854 if (ses->capabilities & CAP_UNICODE) {
2855 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2857 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2858 6 /* max utf8 char length in bytes */ *
2859 (/* server len*/ + 256 /* share len */), nls_codepage);
2860 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
2861 bcc_ptr += 2; /* skip trailing null */
2862 } else { /* ASCII */
2863 strcpy(bcc_ptr, tree);
2864 bcc_ptr += strlen(tree) + 1;
2866 strcpy(bcc_ptr, "?????");
2867 bcc_ptr += strlen("?????");
2869 count = bcc_ptr - &pSMB->Password[0];
2870 pSMB->hdr.smb_buf_length += count;
2871 pSMB->ByteCount = cpu_to_le16(count);
2873 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2876 /* above now done in SendReceive */
2877 if ((rc == 0) && (tcon != NULL)) {
2880 tcon->tidStatus = CifsGood;
2881 tcon->need_reconnect = false;
2882 tcon->tid = smb_buffer_response->Tid;
2883 bcc_ptr = pByteArea(smb_buffer_response);
2884 bytes_left = BCC(smb_buffer_response);
2885 length = strnlen(bcc_ptr, bytes_left - 2);
2886 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
2892 /* skip service field (NB: this field is always ASCII) */
2894 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
2895 (bcc_ptr[2] == 'C')) {
2896 cFYI(1, "IPC connection");
2899 } else if (length == 2) {
2900 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
2901 /* the most common case */
2902 cFYI(1, "disk share connection");
2905 bcc_ptr += length + 1;
2906 bytes_left -= (length + 1);
2907 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
2909 /* mostly informational -- no need to fail on error here */
2910 kfree(tcon->nativeFileSystem);
2911 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
2912 bytes_left, is_unicode,
2915 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
2917 if ((smb_buffer_response->WordCount == 3) ||
2918 (smb_buffer_response->WordCount == 7))
2919 /* field is in same location */
2920 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
2923 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
2924 } else if ((rc == 0) && tcon == NULL) {
2925 /* all we need to save for IPC$ connection */
2926 ses->ipc_tid = smb_buffer_response->Tid;
2929 cifs_buf_release(smb_buffer);
2934 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
2940 cifs_put_tcon(cifs_sb->tcon);
2942 cifs_sb->tcon = NULL;
2943 tmp = cifs_sb->prepath;
2944 cifs_sb->prepathlen = 0;
2945 cifs_sb->prepath = NULL;
2951 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
2954 struct TCP_Server_Info *server = ses->server;
2956 /* only send once per connect */
2957 if (server->maxBuf != 0)
2960 rc = CIFSSMBNegotiate(xid, ses);
2961 if (rc == -EAGAIN) {
2962 /* retry only once on 1st time connection */
2963 rc = CIFSSMBNegotiate(xid, ses);
2968 spin_lock(&GlobalMid_Lock);
2969 if (server->tcpStatus != CifsExiting)
2970 server->tcpStatus = CifsGood;
2973 spin_unlock(&GlobalMid_Lock);
2981 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
2982 struct nls_table *nls_info)
2985 struct TCP_Server_Info *server = ses->server;
2988 ses->capabilities = server->capabilities;
2989 if (linuxExtEnabled == 0)
2990 ses->capabilities &= (~CAP_UNIX);
2992 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
2993 server->secMode, server->capabilities, server->timeAdj);
2995 rc = CIFS_SessSetup(xid, ses, nls_info);
2997 cERROR(1, "Send error in SessSetup = %d", rc);
2999 cFYI(1, "CIFS Session Established successfully");
3000 spin_lock(&GlobalMid_Lock);
3001 ses->status = CifsGood;
3002 ses->need_reconnect = false;
3003 spin_unlock(&GlobalMid_Lock);