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 sockaddr_storage srcaddr
; /* allow binding to a local IP */
109 struct nls_table
*local_nls
;
112 static int ipv4_connect(struct TCP_Server_Info
*server
);
113 static int ipv6_connect(struct TCP_Server_Info
*server
);
116 * cifs tcp session reconnection
118 * mark tcp session as reconnecting so temporarily locked
119 * mark all smb sessions as reconnecting for tcp session
120 * reconnect tcp session
121 * wake up waiters on reconnection? - (not needed currently)
124 cifs_reconnect(struct TCP_Server_Info
*server
)
127 struct list_head
*tmp
, *tmp2
;
128 struct cifsSesInfo
*ses
;
129 struct cifsTconInfo
*tcon
;
130 struct mid_q_entry
*mid_entry
;
132 spin_lock(&GlobalMid_Lock
);
133 if (server
->tcpStatus
== CifsExiting
) {
134 /* the demux thread will exit normally
135 next time through the loop */
136 spin_unlock(&GlobalMid_Lock
);
139 server
->tcpStatus
= CifsNeedReconnect
;
140 spin_unlock(&GlobalMid_Lock
);
143 cFYI(1, "Reconnecting tcp session");
145 /* before reconnecting the tcp session, mark the smb session (uid)
146 and the tid bad so they are not used until reconnected */
147 read_lock(&cifs_tcp_ses_lock
);
148 list_for_each(tmp
, &server
->smb_ses_list
) {
149 ses
= list_entry(tmp
, struct cifsSesInfo
, smb_ses_list
);
150 ses
->need_reconnect
= true;
152 list_for_each(tmp2
, &ses
->tcon_list
) {
153 tcon
= list_entry(tmp2
, struct cifsTconInfo
, tcon_list
);
154 tcon
->need_reconnect
= true;
157 read_unlock(&cifs_tcp_ses_lock
);
158 /* do not want to be sending data on a socket we are freeing */
159 mutex_lock(&server
->srv_mutex
);
160 if (server
->ssocket
) {
161 cFYI(1, "State: 0x%x Flags: 0x%lx", server
->ssocket
->state
,
162 server
->ssocket
->flags
);
163 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
164 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
165 server
->ssocket
->state
,
166 server
->ssocket
->flags
);
167 sock_release(server
->ssocket
);
168 server
->ssocket
= NULL
;
171 spin_lock(&GlobalMid_Lock
);
172 list_for_each(tmp
, &server
->pending_mid_q
) {
173 mid_entry
= list_entry(tmp
, struct
176 if (mid_entry
->midState
== MID_REQUEST_SUBMITTED
) {
177 /* Mark other intransit requests as needing
178 retry so we do not immediately mark the
179 session bad again (ie after we reconnect
180 below) as they timeout too */
181 mid_entry
->midState
= MID_RETRY_NEEDED
;
184 spin_unlock(&GlobalMid_Lock
);
185 mutex_unlock(&server
->srv_mutex
);
187 while ((server
->tcpStatus
!= CifsExiting
) &&
188 (server
->tcpStatus
!= CifsGood
)) {
190 if (server
->addr
.sockAddr6
.sin6_family
== AF_INET6
)
191 rc
= ipv6_connect(server
);
193 rc
= ipv4_connect(server
);
195 cFYI(1, "reconnect error %d", rc
);
198 atomic_inc(&tcpSesReconnectCount
);
199 spin_lock(&GlobalMid_Lock
);
200 if (server
->tcpStatus
!= CifsExiting
)
201 server
->tcpStatus
= CifsGood
;
202 server
->sequence_number
= 0;
203 spin_unlock(&GlobalMid_Lock
);
204 /* atomic_set(&server->inFlight,0);*/
205 wake_up(&server
->response_q
);
213 0 not a transact2, or all data present
214 >0 transact2 with that much data missing
215 -EINVAL = invalid transact2
218 static int check2ndT2(struct smb_hdr
*pSMB
, unsigned int maxBufSize
)
220 struct smb_t2_rsp
*pSMBt
;
222 int data_in_this_rsp
;
225 if (pSMB
->Command
!= SMB_COM_TRANSACTION2
)
228 /* check for plausible wct, bcc and t2 data and parm sizes */
229 /* check for parm and data offset going beyond end of smb */
230 if (pSMB
->WordCount
!= 10) { /* coalesce_t2 depends on this */
231 cFYI(1, "invalid transact2 word count");
235 pSMBt
= (struct smb_t2_rsp
*)pSMB
;
237 total_data_size
= le16_to_cpu(pSMBt
->t2_rsp
.TotalDataCount
);
238 data_in_this_rsp
= le16_to_cpu(pSMBt
->t2_rsp
.DataCount
);
240 remaining
= total_data_size
- data_in_this_rsp
;
244 else if (remaining
< 0) {
245 cFYI(1, "total data %d smaller than data in frame %d",
246 total_data_size
, data_in_this_rsp
);
249 cFYI(1, "missing %d bytes from transact2, check next response",
251 if (total_data_size
> maxBufSize
) {
252 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
253 total_data_size
, maxBufSize
);
260 static int coalesce_t2(struct smb_hdr
*psecond
, struct smb_hdr
*pTargetSMB
)
262 struct smb_t2_rsp
*pSMB2
= (struct smb_t2_rsp
*)psecond
;
263 struct smb_t2_rsp
*pSMBt
= (struct smb_t2_rsp
*)pTargetSMB
;
268 char *data_area_of_target
;
269 char *data_area_of_buf2
;
272 total_data_size
= le16_to_cpu(pSMBt
->t2_rsp
.TotalDataCount
);
274 if (total_data_size
!= le16_to_cpu(pSMB2
->t2_rsp
.TotalDataCount
)) {
275 cFYI(1, "total data size of primary and secondary t2 differ");
278 total_in_buf
= le16_to_cpu(pSMBt
->t2_rsp
.DataCount
);
280 remaining
= total_data_size
- total_in_buf
;
285 if (remaining
== 0) /* nothing to do, ignore */
288 total_in_buf2
= le16_to_cpu(pSMB2
->t2_rsp
.DataCount
);
289 if (remaining
< total_in_buf2
) {
290 cFYI(1, "transact2 2nd response contains too much data");
293 /* find end of first SMB data area */
294 data_area_of_target
= (char *)&pSMBt
->hdr
.Protocol
+
295 le16_to_cpu(pSMBt
->t2_rsp
.DataOffset
);
296 /* validate target area */
298 data_area_of_buf2
= (char *) &pSMB2
->hdr
.Protocol
+
299 le16_to_cpu(pSMB2
->t2_rsp
.DataOffset
);
301 data_area_of_target
+= total_in_buf
;
303 /* copy second buffer into end of first buffer */
304 memcpy(data_area_of_target
, data_area_of_buf2
, total_in_buf2
);
305 total_in_buf
+= total_in_buf2
;
306 pSMBt
->t2_rsp
.DataCount
= cpu_to_le16(total_in_buf
);
307 byte_count
= le16_to_cpu(BCC_LE(pTargetSMB
));
308 byte_count
+= total_in_buf2
;
309 BCC_LE(pTargetSMB
) = cpu_to_le16(byte_count
);
311 byte_count
= pTargetSMB
->smb_buf_length
;
312 byte_count
+= total_in_buf2
;
314 /* BB also add check that we are not beyond maximum buffer size */
316 pTargetSMB
->smb_buf_length
= byte_count
;
318 if (remaining
== total_in_buf2
) {
319 cFYI(1, "found the last secondary response");
320 return 0; /* we are done */
321 } else /* more responses to go */
327 cifs_demultiplex_thread(struct TCP_Server_Info
*server
)
330 unsigned int pdu_length
, total_read
;
331 struct smb_hdr
*smb_buffer
= NULL
;
332 struct smb_hdr
*bigbuf
= NULL
;
333 struct smb_hdr
*smallbuf
= NULL
;
334 struct msghdr smb_msg
;
336 struct socket
*csocket
= server
->ssocket
;
337 struct list_head
*tmp
;
338 struct cifsSesInfo
*ses
;
339 struct task_struct
*task_to_wake
= NULL
;
340 struct mid_q_entry
*mid_entry
;
342 bool isLargeBuf
= false;
346 current
->flags
|= PF_MEMALLOC
;
347 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current
));
349 length
= atomic_inc_return(&tcpSesAllocCount
);
351 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
355 while (server
->tcpStatus
!= CifsExiting
) {
358 if (bigbuf
== NULL
) {
359 bigbuf
= cifs_buf_get();
361 cERROR(1, "No memory for large SMB response");
363 /* retry will check if exiting */
366 } else if (isLargeBuf
) {
367 /* we are reusing a dirty large buf, clear its start */
368 memset(bigbuf
, 0, sizeof(struct smb_hdr
));
371 if (smallbuf
== NULL
) {
372 smallbuf
= cifs_small_buf_get();
374 cERROR(1, "No memory for SMB response");
376 /* retry will check if exiting */
379 /* beginning of smb buffer is cleared in our buf_get */
380 } else /* if existing small buf clear beginning */
381 memset(smallbuf
, 0, sizeof(struct smb_hdr
));
385 smb_buffer
= smallbuf
;
386 iov
.iov_base
= smb_buffer
;
388 smb_msg
.msg_control
= NULL
;
389 smb_msg
.msg_controllen
= 0;
390 pdu_length
= 4; /* enough to get RFC1001 header */
393 kernel_recvmsg(csocket
, &smb_msg
,
394 &iov
, 1, pdu_length
, 0 /* BB other flags? */);
396 if (server
->tcpStatus
== CifsExiting
) {
398 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
399 cFYI(1, "Reconnect after server stopped responding");
400 cifs_reconnect(server
);
401 cFYI(1, "call to reconnect done");
402 csocket
= server
->ssocket
;
404 } else if (length
== -ERESTARTSYS
||
407 msleep(1); /* minimum sleep to prevent looping
408 allowing socket to clear and app threads to set
409 tcpStatus CifsNeedReconnect if server hung */
410 if (pdu_length
< 4) {
411 iov
.iov_base
= (4 - pdu_length
) +
413 iov
.iov_len
= pdu_length
;
414 smb_msg
.msg_control
= NULL
;
415 smb_msg
.msg_controllen
= 0;
419 } else if (length
<= 0) {
420 cFYI(1, "Reconnect after unexpected peek error %d",
422 cifs_reconnect(server
);
423 csocket
= server
->ssocket
;
424 wake_up(&server
->response_q
);
426 } else if (length
< pdu_length
) {
427 cFYI(1, "requested %d bytes but only got %d bytes",
429 pdu_length
-= length
;
434 /* The right amount was read from socket - 4 bytes */
435 /* so we can now interpret the length field */
437 /* the first byte big endian of the length field,
438 is actually not part of the length but the type
439 with the most common, zero, as regular data */
440 temp
= *((char *) smb_buffer
);
442 /* Note that FC 1001 length is big endian on the wire,
443 but we convert it here so it is always manipulated
444 as host byte order */
445 pdu_length
= be32_to_cpu((__force __be32
)smb_buffer
->smb_buf_length
);
446 smb_buffer
->smb_buf_length
= pdu_length
;
448 cFYI(1, "rfc1002 length 0x%x", pdu_length
+4);
450 if (temp
== (char) RFC1002_SESSION_KEEP_ALIVE
) {
452 } else if (temp
== (char)RFC1002_POSITIVE_SESSION_RESPONSE
) {
453 cFYI(1, "Good RFC 1002 session rsp");
455 } else if (temp
== (char)RFC1002_NEGATIVE_SESSION_RESPONSE
) {
456 /* we get this from Windows 98 instead of
457 an error on SMB negprot response */
458 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
460 /* give server a second to clean up */
462 /* always try 445 first on reconnect since we get NACK
463 * on some if we ever connected to port 139 (the NACK
464 * is since we do not begin with RFC1001 session
467 cifs_set_port((struct sockaddr
*)
468 &server
->addr
.sockAddr
, CIFS_PORT
);
469 cifs_reconnect(server
);
470 csocket
= server
->ssocket
;
471 wake_up(&server
->response_q
);
473 } else if (temp
!= (char) 0) {
474 cERROR(1, "Unknown RFC 1002 frame");
475 cifs_dump_mem(" Received Data: ", (char *)smb_buffer
,
477 cifs_reconnect(server
);
478 csocket
= server
->ssocket
;
482 /* else we have an SMB response */
483 if ((pdu_length
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
- 4) ||
484 (pdu_length
< sizeof(struct smb_hdr
) - 1 - 4)) {
485 cERROR(1, "Invalid size SMB length %d pdu_length %d",
486 length
, pdu_length
+4);
487 cifs_reconnect(server
);
488 csocket
= server
->ssocket
;
489 wake_up(&server
->response_q
);
496 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
498 memcpy(bigbuf
, smallbuf
, 4);
502 iov
.iov_base
= 4 + (char *)smb_buffer
;
503 iov
.iov_len
= pdu_length
;
504 for (total_read
= 0; total_read
< pdu_length
;
505 total_read
+= length
) {
506 length
= kernel_recvmsg(csocket
, &smb_msg
, &iov
, 1,
507 pdu_length
- total_read
, 0);
508 if (server
->tcpStatus
== CifsExiting
) {
512 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
513 cifs_reconnect(server
);
514 csocket
= server
->ssocket
;
515 /* Reconnect wakes up rspns q */
516 /* Now we will reread sock */
519 } else if (length
== -ERESTARTSYS
||
522 msleep(1); /* minimum sleep to prevent looping,
523 allowing socket to clear and app
524 threads to set tcpStatus
525 CifsNeedReconnect if server hung*/
528 } else if (length
<= 0) {
529 cERROR(1, "Received no data, expecting %d",
530 pdu_length
- total_read
);
531 cifs_reconnect(server
);
532 csocket
= server
->ssocket
;
539 else if (reconnect
== 1)
542 length
+= 4; /* account for rfc1002 hdr */
545 dump_smb(smb_buffer
, length
);
546 if (checkSMB(smb_buffer
, smb_buffer
->Mid
, total_read
+4)) {
547 cifs_dump_mem("Bad SMB: ", smb_buffer
, 48);
553 spin_lock(&GlobalMid_Lock
);
554 list_for_each(tmp
, &server
->pending_mid_q
) {
555 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
557 if ((mid_entry
->mid
== smb_buffer
->Mid
) &&
558 (mid_entry
->midState
== MID_REQUEST_SUBMITTED
) &&
559 (mid_entry
->command
== smb_buffer
->Command
)) {
560 if (check2ndT2(smb_buffer
,server
->maxBuf
) > 0) {
561 /* We have a multipart transact2 resp */
563 if (mid_entry
->resp_buf
) {
564 /* merge response - fix up 1st*/
565 if (coalesce_t2(smb_buffer
,
566 mid_entry
->resp_buf
)) {
567 mid_entry
->multiRsp
=
571 /* all parts received */
572 mid_entry
->multiEnd
=
578 cERROR(1, "1st trans2 resp needs bigbuf");
579 /* BB maybe we can fix this up, switch
580 to already allocated large buffer? */
582 /* Have first buffer */
583 mid_entry
->resp_buf
=
585 mid_entry
->largeBuf
=
592 mid_entry
->resp_buf
= smb_buffer
;
593 mid_entry
->largeBuf
= isLargeBuf
;
595 task_to_wake
= mid_entry
->tsk
;
596 mid_entry
->midState
= MID_RESPONSE_RECEIVED
;
597 #ifdef CONFIG_CIFS_STATS2
598 mid_entry
->when_received
= jiffies
;
600 /* so we do not time out requests to server
601 which is still responding (since server could
602 be busy but not dead) */
603 server
->lstrp
= jiffies
;
607 spin_unlock(&GlobalMid_Lock
);
609 /* Was previous buf put in mpx struct for multi-rsp? */
611 /* smb buffer will be freed by user thread */
617 wake_up_process(task_to_wake
);
618 } else if (!is_valid_oplock_break(smb_buffer
, server
) &&
620 cERROR(1, "No task to wake, unknown frame received! "
621 "NumMids %d", midCount
.counter
);
622 cifs_dump_mem("Received Data is: ", (char *)smb_buffer
,
623 sizeof(struct smb_hdr
));
624 #ifdef CONFIG_CIFS_DEBUG2
625 cifs_dump_detail(smb_buffer
);
626 cifs_dump_mids(server
);
627 #endif /* CIFS_DEBUG2 */
630 } /* end while !EXITING */
632 /* take it off the list, if it's not already */
633 write_lock(&cifs_tcp_ses_lock
);
634 list_del_init(&server
->tcp_ses_list
);
635 write_unlock(&cifs_tcp_ses_lock
);
637 spin_lock(&GlobalMid_Lock
);
638 server
->tcpStatus
= CifsExiting
;
639 spin_unlock(&GlobalMid_Lock
);
640 wake_up_all(&server
->response_q
);
642 /* check if we have blocked requests that need to free */
643 /* Note that cifs_max_pending is normally 50, but
644 can be set at module install time to as little as two */
645 spin_lock(&GlobalMid_Lock
);
646 if (atomic_read(&server
->inFlight
) >= cifs_max_pending
)
647 atomic_set(&server
->inFlight
, cifs_max_pending
- 1);
648 /* We do not want to set the max_pending too low or we
649 could end up with the counter going negative */
650 spin_unlock(&GlobalMid_Lock
);
651 /* Although there should not be any requests blocked on
652 this queue it can not hurt to be paranoid and try to wake up requests
653 that may haven been blocked when more than 50 at time were on the wire
654 to the same server - they now will see the session is in exit state
655 and get out of SendReceive. */
656 wake_up_all(&server
->request_q
);
657 /* give those requests time to exit */
660 if (server
->ssocket
) {
661 sock_release(csocket
);
662 server
->ssocket
= NULL
;
664 /* buffer usuallly freed in free_mid - need to free it here on exit */
665 cifs_buf_release(bigbuf
);
666 if (smallbuf
) /* no sense logging a debug message if NULL */
667 cifs_small_buf_release(smallbuf
);
670 * BB: we shouldn't have to do any of this. It shouldn't be
671 * possible to exit from the thread with active SMB sessions
673 read_lock(&cifs_tcp_ses_lock
);
674 if (list_empty(&server
->pending_mid_q
)) {
675 /* loop through server session structures attached to this and
677 list_for_each(tmp
, &server
->smb_ses_list
) {
678 ses
= list_entry(tmp
, struct cifsSesInfo
,
680 ses
->status
= CifsExiting
;
683 read_unlock(&cifs_tcp_ses_lock
);
685 /* although we can not zero the server struct pointer yet,
686 since there are active requests which may depnd on them,
687 mark the corresponding SMB sessions as exiting too */
688 list_for_each(tmp
, &server
->smb_ses_list
) {
689 ses
= list_entry(tmp
, struct cifsSesInfo
,
691 ses
->status
= CifsExiting
;
694 spin_lock(&GlobalMid_Lock
);
695 list_for_each(tmp
, &server
->pending_mid_q
) {
696 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
697 if (mid_entry
->midState
== MID_REQUEST_SUBMITTED
) {
698 cFYI(1, "Clearing Mid 0x%x - waking up ",
700 task_to_wake
= mid_entry
->tsk
;
702 wake_up_process(task_to_wake
);
705 spin_unlock(&GlobalMid_Lock
);
706 read_unlock(&cifs_tcp_ses_lock
);
707 /* 1/8th of sec is more than enough time for them to exit */
711 if (!list_empty(&server
->pending_mid_q
)) {
712 /* mpx threads have not exited yet give them
713 at least the smb send timeout time for long ops */
714 /* due to delays on oplock break requests, we need
715 to wait at least 45 seconds before giving up
716 on a request getting a response and going ahead
718 cFYI(1, "Wait for exit from demultiplex thread");
720 /* if threads still have not exited they are probably never
721 coming home not much else we can do but free the memory */
724 /* last chance to mark ses pointers invalid
725 if there are any pointing to this (e.g
726 if a crazy root user tried to kill cifsd
727 kernel thread explicitly this might happen) */
728 /* BB: This shouldn't be necessary, see above */
729 read_lock(&cifs_tcp_ses_lock
);
730 list_for_each(tmp
, &server
->smb_ses_list
) {
731 ses
= list_entry(tmp
, struct cifsSesInfo
, smb_ses_list
);
734 read_unlock(&cifs_tcp_ses_lock
);
736 kfree(server
->hostname
);
737 task_to_wake
= xchg(&server
->tsk
, NULL
);
740 length
= atomic_dec_return(&tcpSesAllocCount
);
742 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
745 /* if server->tsk was NULL then wait for a signal before exiting */
747 set_current_state(TASK_INTERRUPTIBLE
);
748 while (!signal_pending(current
)) {
750 set_current_state(TASK_INTERRUPTIBLE
);
752 set_current_state(TASK_RUNNING
);
755 module_put_and_exit(0);
758 /* extract the host portion of the UNC string */
760 extract_hostname(const char *unc
)
766 /* skip double chars at beginning of string */
767 /* BB: check validity of these bytes? */
770 /* delimiter between hostname and sharename is always '\\' now */
771 delim
= strchr(src
, '\\');
773 return ERR_PTR(-EINVAL
);
776 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
778 return ERR_PTR(-ENOMEM
);
780 memcpy(dst
, src
, len
);
787 cifs_parse_mount_options(char *options
, const char *devname
,
792 unsigned int temp_len
, i
, j
;
794 short int override_uid
= -1;
795 short int override_gid
= -1;
796 bool uid_specified
= false;
797 bool gid_specified
= false;
802 if (Local_System_Name
[0] != 0)
803 memcpy(vol
->source_rfc1001_name
, Local_System_Name
, 15);
805 char *nodename
= utsname()->nodename
;
806 int n
= strnlen(nodename
, 15);
807 memset(vol
->source_rfc1001_name
, 0x20, 15);
808 for (i
= 0; i
< n
; i
++) {
809 /* does not have to be perfect mapping since field is
810 informational, only used for servers that do not support
811 port 445 and it can be overridden at mount time */
812 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
815 vol
->source_rfc1001_name
[15] = 0;
816 /* null target name indicates to use *SMBSERVR default called name
817 if we end up sending RFC1001 session initialize */
818 vol
->target_rfc1001_name
[0] = 0;
819 vol
->cred_uid
= current_uid();
820 vol
->linux_uid
= current_uid();
821 vol
->linux_gid
= current_gid();
823 /* default to only allowing write access to owner of the mount */
824 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
826 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
827 /* default is always to request posix paths. */
828 vol
->posix_paths
= 1;
829 /* default to using server inode numbers where available */
835 if (strncmp(options
, "sep=", 4) == 0) {
836 if (options
[4] != 0) {
837 separator
[0] = options
[4];
840 cFYI(1, "Null separator not allowed");
844 while ((data
= strsep(&options
, separator
)) != NULL
) {
847 if ((value
= strchr(data
, '=')) != NULL
)
850 /* Have to parse this before we parse for "user" */
851 if (strnicmp(data
, "user_xattr", 10) == 0) {
853 } else if (strnicmp(data
, "nouser_xattr", 12) == 0) {
855 } else if (strnicmp(data
, "user", 4) == 0) {
858 "CIFS: invalid or missing username\n");
859 return 1; /* needs_arg; */
860 } else if (!*value
) {
861 /* null user, ie anonymous, authentication */
864 if (strnlen(value
, 200) < 200) {
865 vol
->username
= value
;
867 printk(KERN_WARNING
"CIFS: username too long\n");
870 } else if (strnicmp(data
, "pass", 4) == 0) {
872 vol
->password
= NULL
;
874 } else if (value
[0] == 0) {
875 /* check if string begins with double comma
876 since that would mean the password really
877 does start with a comma, and would not
878 indicate an empty string */
879 if (value
[1] != separator
[0]) {
880 vol
->password
= NULL
;
884 temp_len
= strlen(value
);
885 /* removed password length check, NTLM passwords
886 can be arbitrarily long */
888 /* if comma in password, the string will be
889 prematurely null terminated. Commas in password are
890 specified across the cifs mount interface by a double
891 comma ie ,, and a comma used as in other cases ie ','
892 as a parameter delimiter/separator is single and due
893 to the strsep above is temporarily zeroed. */
895 /* NB: password legally can have multiple commas and
896 the only illegal character in a password is null */
898 if ((value
[temp_len
] == 0) &&
899 (value
[temp_len
+1] == separator
[0])) {
901 value
[temp_len
] = separator
[0];
902 temp_len
+= 2; /* move after second comma */
903 while (value
[temp_len
] != 0) {
904 if (value
[temp_len
] == separator
[0]) {
905 if (value
[temp_len
+1] ==
907 /* skip second comma */
910 /* single comma indicating start
917 if (value
[temp_len
] == 0) {
921 /* point option to start of next parm */
922 options
= value
+ temp_len
+ 1;
924 /* go from value to value + temp_len condensing
925 double commas to singles. Note that this ends up
926 allocating a few bytes too many, which is ok */
927 vol
->password
= kzalloc(temp_len
, GFP_KERNEL
);
928 if (vol
->password
== NULL
) {
929 printk(KERN_WARNING
"CIFS: no memory "
933 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
934 vol
->password
[j
] = value
[i
];
935 if (value
[i
] == separator
[0]
936 && value
[i
+1] == separator
[0]) {
937 /* skip second comma */
941 vol
->password
[j
] = 0;
943 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
944 if (vol
->password
== NULL
) {
945 printk(KERN_WARNING
"CIFS: no memory "
949 strcpy(vol
->password
, value
);
951 } else if (!strnicmp(data
, "ip", 2) ||
952 !strnicmp(data
, "addr", 4)) {
953 if (!value
|| !*value
) {
955 } else if (strnlen(value
, INET6_ADDRSTRLEN
) <
959 printk(KERN_WARNING
"CIFS: ip address "
963 } else if (strnicmp(data
, "sec", 3) == 0) {
964 if (!value
|| !*value
) {
965 cERROR(1, "no security value specified");
967 } else if (strnicmp(value
, "krb5i", 5) == 0) {
968 vol
->secFlg
|= CIFSSEC_MAY_KRB5
|
970 } else if (strnicmp(value
, "krb5p", 5) == 0) {
971 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
973 cERROR(1, "Krb5 cifs privacy not supported");
975 } else if (strnicmp(value
, "krb5", 4) == 0) {
976 vol
->secFlg
|= CIFSSEC_MAY_KRB5
;
977 #ifdef CONFIG_CIFS_EXPERIMENTAL
978 } else if (strnicmp(value
, "ntlmsspi", 8) == 0) {
979 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
|
981 } else if (strnicmp(value
, "ntlmssp", 7) == 0) {
982 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
;
984 } else if (strnicmp(value
, "ntlmv2i", 7) == 0) {
985 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
|
987 } else if (strnicmp(value
, "ntlmv2", 6) == 0) {
988 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
989 } else if (strnicmp(value
, "ntlmi", 5) == 0) {
990 vol
->secFlg
|= CIFSSEC_MAY_NTLM
|
992 } else if (strnicmp(value
, "ntlm", 4) == 0) {
993 /* ntlm is default so can be turned off too */
994 vol
->secFlg
|= CIFSSEC_MAY_NTLM
;
995 } else if (strnicmp(value
, "nontlm", 6) == 0) {
996 /* BB is there a better way to do this? */
997 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
998 #ifdef CONFIG_CIFS_WEAK_PW_HASH
999 } else if (strnicmp(value
, "lanman", 6) == 0) {
1000 vol
->secFlg
|= CIFSSEC_MAY_LANMAN
;
1002 } else if (strnicmp(value
, "none", 4) == 0) {
1005 cERROR(1, "bad security option: %s", value
);
1008 } else if ((strnicmp(data
, "unc", 3) == 0)
1009 || (strnicmp(data
, "target", 6) == 0)
1010 || (strnicmp(data
, "path", 4) == 0)) {
1011 if (!value
|| !*value
) {
1012 printk(KERN_WARNING
"CIFS: invalid path to "
1013 "network resource\n");
1014 return 1; /* needs_arg; */
1016 if ((temp_len
= strnlen(value
, 300)) < 300) {
1017 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1018 if (vol
->UNC
== NULL
)
1020 strcpy(vol
->UNC
, value
);
1021 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1024 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1026 "CIFS: UNC Path does not begin "
1027 "with // or \\\\ \n");
1031 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1034 } else if ((strnicmp(data
, "domain", 3) == 0)
1035 || (strnicmp(data
, "workgroup", 5) == 0)) {
1036 if (!value
|| !*value
) {
1037 printk(KERN_WARNING
"CIFS: invalid domain name\n");
1038 return 1; /* needs_arg; */
1040 /* BB are there cases in which a comma can be valid in
1041 a domain name and need special handling? */
1042 if (strnlen(value
, 256) < 256) {
1043 vol
->domainname
= value
;
1044 cFYI(1, "Domain name set");
1046 printk(KERN_WARNING
"CIFS: domain name too "
1050 } else if (strnicmp(data
, "srcaddr", 7) == 0) {
1051 vol
->srcaddr
.ss_family
= AF_UNSPEC
;
1053 if (!value
|| !*value
) {
1054 printk(KERN_WARNING
"CIFS: srcaddr value"
1055 " not specified.\n");
1056 return 1; /* needs_arg; */
1058 i
= cifs_convert_address((struct sockaddr
*)&vol
->srcaddr
,
1059 value
, strlen(value
));
1061 printk(KERN_WARNING
"CIFS: Could not parse"
1066 } else if (strnicmp(data
, "prefixpath", 10) == 0) {
1067 if (!value
|| !*value
) {
1069 "CIFS: invalid path prefix\n");
1070 return 1; /* needs_argument */
1072 if ((temp_len
= strnlen(value
, 1024)) < 1024) {
1073 if (value
[0] != '/')
1074 temp_len
++; /* missing leading slash */
1075 vol
->prepath
= kmalloc(temp_len
+1, GFP_KERNEL
);
1076 if (vol
->prepath
== NULL
)
1078 if (value
[0] != '/') {
1079 vol
->prepath
[0] = '/';
1080 strcpy(vol
->prepath
+1, value
);
1082 strcpy(vol
->prepath
, value
);
1083 cFYI(1, "prefix path %s", vol
->prepath
);
1085 printk(KERN_WARNING
"CIFS: prefix too long\n");
1088 } else if (strnicmp(data
, "iocharset", 9) == 0) {
1089 if (!value
|| !*value
) {
1090 printk(KERN_WARNING
"CIFS: invalid iocharset "
1092 return 1; /* needs_arg; */
1094 if (strnlen(value
, 65) < 65) {
1095 if (strnicmp(value
, "default", 7))
1096 vol
->iocharset
= value
;
1097 /* if iocharset not set then load_nls_default
1098 is used by caller */
1099 cFYI(1, "iocharset set to %s", value
);
1101 printk(KERN_WARNING
"CIFS: iocharset name "
1105 } else if (!strnicmp(data
, "uid", 3) && value
&& *value
) {
1106 vol
->linux_uid
= simple_strtoul(value
, &value
, 0);
1107 uid_specified
= true;
1108 } else if (!strnicmp(data
, "forceuid", 8)) {
1110 } else if (!strnicmp(data
, "noforceuid", 10)) {
1112 } else if (!strnicmp(data
, "gid", 3) && value
&& *value
) {
1113 vol
->linux_gid
= simple_strtoul(value
, &value
, 0);
1114 gid_specified
= true;
1115 } else if (!strnicmp(data
, "forcegid", 8)) {
1117 } else if (!strnicmp(data
, "noforcegid", 10)) {
1119 } else if (strnicmp(data
, "file_mode", 4) == 0) {
1120 if (value
&& *value
) {
1122 simple_strtoul(value
, &value
, 0);
1124 } else if (strnicmp(data
, "dir_mode", 4) == 0) {
1125 if (value
&& *value
) {
1127 simple_strtoul(value
, &value
, 0);
1129 } else if (strnicmp(data
, "dirmode", 4) == 0) {
1130 if (value
&& *value
) {
1132 simple_strtoul(value
, &value
, 0);
1134 } else if (strnicmp(data
, "port", 4) == 0) {
1135 if (value
&& *value
) {
1137 simple_strtoul(value
, &value
, 0);
1139 } else if (strnicmp(data
, "rsize", 5) == 0) {
1140 if (value
&& *value
) {
1142 simple_strtoul(value
, &value
, 0);
1144 } else if (strnicmp(data
, "wsize", 5) == 0) {
1145 if (value
&& *value
) {
1147 simple_strtoul(value
, &value
, 0);
1149 } else if (strnicmp(data
, "sockopt", 5) == 0) {
1150 if (!value
|| !*value
) {
1151 cERROR(1, "no socket option specified");
1153 } else if (strnicmp(value
, "TCP_NODELAY", 11) == 0) {
1154 vol
->sockopt_tcp_nodelay
= 1;
1156 } else if (strnicmp(data
, "netbiosname", 4) == 0) {
1157 if (!value
|| !*value
|| (*value
== ' ')) {
1158 cFYI(1, "invalid (empty) netbiosname");
1160 memset(vol
->source_rfc1001_name
, 0x20, 15);
1161 for (i
= 0; i
< 15; i
++) {
1162 /* BB are there cases in which a comma can be
1163 valid in this workstation netbios name (and need
1164 special handling)? */
1166 /* We do not uppercase netbiosname for user */
1170 vol
->source_rfc1001_name
[i
] =
1173 /* The string has 16th byte zero still from
1174 set at top of the function */
1175 if ((i
== 15) && (value
[i
] != 0))
1176 printk(KERN_WARNING
"CIFS: netbiosname"
1177 " longer than 15 truncated.\n");
1179 } else if (strnicmp(data
, "servern", 7) == 0) {
1180 /* servernetbiosname specified override *SMBSERVER */
1181 if (!value
|| !*value
|| (*value
== ' ')) {
1182 cFYI(1, "empty server netbiosname specified");
1184 /* last byte, type, is 0x20 for servr type */
1185 memset(vol
->target_rfc1001_name
, 0x20, 16);
1187 for (i
= 0; i
< 15; i
++) {
1188 /* BB are there cases in which a comma can be
1189 valid in this workstation netbios name
1190 (and need special handling)? */
1192 /* user or mount helper must uppercase
1197 vol
->target_rfc1001_name
[i
] =
1200 /* The string has 16th byte zero still from
1201 set at top of the function */
1202 if ((i
== 15) && (value
[i
] != 0))
1203 printk(KERN_WARNING
"CIFS: server net"
1204 "biosname longer than 15 truncated.\n");
1206 } else if (strnicmp(data
, "credentials", 4) == 0) {
1208 } else if (strnicmp(data
, "version", 3) == 0) {
1210 } else if (strnicmp(data
, "guest", 5) == 0) {
1212 } else if (strnicmp(data
, "rw", 2) == 0) {
1214 } else if (strnicmp(data
, "ro", 2) == 0) {
1216 } else if (strnicmp(data
, "noblocksend", 11) == 0) {
1217 vol
->noblocksnd
= 1;
1218 } else if (strnicmp(data
, "noautotune", 10) == 0) {
1219 vol
->noautotune
= 1;
1220 } else if ((strnicmp(data
, "suid", 4) == 0) ||
1221 (strnicmp(data
, "nosuid", 6) == 0) ||
1222 (strnicmp(data
, "exec", 4) == 0) ||
1223 (strnicmp(data
, "noexec", 6) == 0) ||
1224 (strnicmp(data
, "nodev", 5) == 0) ||
1225 (strnicmp(data
, "noauto", 6) == 0) ||
1226 (strnicmp(data
, "dev", 3) == 0)) {
1227 /* The mount tool or mount.cifs helper (if present)
1228 uses these opts to set flags, and the flags are read
1229 by the kernel vfs layer before we get here (ie
1230 before read super) so there is no point trying to
1231 parse these options again and set anything and it
1232 is ok to just ignore them */
1234 } else if (strnicmp(data
, "hard", 4) == 0) {
1236 } else if (strnicmp(data
, "soft", 4) == 0) {
1238 } else if (strnicmp(data
, "perm", 4) == 0) {
1240 } else if (strnicmp(data
, "noperm", 6) == 0) {
1242 } else if (strnicmp(data
, "mapchars", 8) == 0) {
1244 } else if (strnicmp(data
, "nomapchars", 10) == 0) {
1246 } else if (strnicmp(data
, "sfu", 3) == 0) {
1248 } else if (strnicmp(data
, "nosfu", 5) == 0) {
1250 } else if (strnicmp(data
, "nodfs", 5) == 0) {
1252 } else if (strnicmp(data
, "posixpaths", 10) == 0) {
1253 vol
->posix_paths
= 1;
1254 } else if (strnicmp(data
, "noposixpaths", 12) == 0) {
1255 vol
->posix_paths
= 0;
1256 } else if (strnicmp(data
, "nounix", 6) == 0) {
1257 vol
->no_linux_ext
= 1;
1258 } else if (strnicmp(data
, "nolinux", 7) == 0) {
1259 vol
->no_linux_ext
= 1;
1260 } else if ((strnicmp(data
, "nocase", 6) == 0) ||
1261 (strnicmp(data
, "ignorecase", 10) == 0)) {
1263 } else if (strnicmp(data
, "mand", 4) == 0) {
1265 } else if (strnicmp(data
, "nomand", 6) == 0) {
1267 } else if (strnicmp(data
, "_netdev", 7) == 0) {
1269 } else if (strnicmp(data
, "brl", 3) == 0) {
1271 } else if ((strnicmp(data
, "nobrl", 5) == 0) ||
1272 (strnicmp(data
, "nolock", 6) == 0)) {
1274 /* turn off mandatory locking in mode
1275 if remote locking is turned off since the
1276 local vfs will do advisory */
1277 if (vol
->file_mode
==
1278 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1279 vol
->file_mode
= S_IALLUGO
;
1280 } else if (strnicmp(data
, "forcemandatorylock", 9) == 0) {
1281 /* will take the shorter form "forcemand" as well */
1282 /* This mount option will force use of mandatory
1283 (DOS/Windows style) byte range locks, instead of
1284 using posix advisory byte range locks, even if the
1285 Unix extensions are available and posix locks would
1286 be supported otherwise. If Unix extensions are not
1287 negotiated this has no effect since mandatory locks
1288 would be used (mandatory locks is all that those
1289 those servers support) */
1291 } else if (strnicmp(data
, "setuids", 7) == 0) {
1293 } else if (strnicmp(data
, "nosetuids", 9) == 0) {
1295 } else if (strnicmp(data
, "dynperm", 7) == 0) {
1296 vol
->dynperm
= true;
1297 } else if (strnicmp(data
, "nodynperm", 9) == 0) {
1298 vol
->dynperm
= false;
1299 } else if (strnicmp(data
, "nohard", 6) == 0) {
1301 } else if (strnicmp(data
, "nosoft", 6) == 0) {
1303 } else if (strnicmp(data
, "nointr", 6) == 0) {
1305 } else if (strnicmp(data
, "intr", 4) == 0) {
1307 } else if (strnicmp(data
, "nostrictsync", 12) == 0) {
1308 vol
->nostrictsync
= 1;
1309 } else if (strnicmp(data
, "strictsync", 10) == 0) {
1310 vol
->nostrictsync
= 0;
1311 } else if (strnicmp(data
, "serverino", 7) == 0) {
1312 vol
->server_ino
= 1;
1313 } else if (strnicmp(data
, "noserverino", 9) == 0) {
1314 vol
->server_ino
= 0;
1315 } else if (strnicmp(data
, "cifsacl", 7) == 0) {
1317 } else if (strnicmp(data
, "nocifsacl", 9) == 0) {
1319 } else if (strnicmp(data
, "acl", 3) == 0) {
1320 vol
->no_psx_acl
= 0;
1321 } else if (strnicmp(data
, "noacl", 5) == 0) {
1322 vol
->no_psx_acl
= 1;
1323 #ifdef CONFIG_CIFS_EXPERIMENTAL
1324 } else if (strnicmp(data
, "locallease", 6) == 0) {
1325 vol
->local_lease
= 1;
1327 } else if (strnicmp(data
, "sign", 4) == 0) {
1328 vol
->secFlg
|= CIFSSEC_MUST_SIGN
;
1329 } else if (strnicmp(data
, "seal", 4) == 0) {
1330 /* we do not do the following in secFlags because seal
1331 is a per tree connection (mount) not a per socket
1332 or per-smb connection option in the protocol */
1333 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1335 } else if (strnicmp(data
, "direct", 6) == 0) {
1337 } else if (strnicmp(data
, "forcedirectio", 13) == 0) {
1339 } else if (strnicmp(data
, "noac", 4) == 0) {
1340 printk(KERN_WARNING
"CIFS: Mount option noac not "
1341 "supported. Instead set "
1342 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1343 } else if (strnicmp(data
, "fsc", 3) == 0) {
1346 printk(KERN_WARNING
"CIFS: Unknown mount option %s\n",
1349 if (vol
->UNC
== NULL
) {
1350 if (devname
== NULL
) {
1351 printk(KERN_WARNING
"CIFS: Missing UNC name for mount "
1355 if ((temp_len
= strnlen(devname
, 300)) < 300) {
1356 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1357 if (vol
->UNC
== NULL
)
1359 strcpy(vol
->UNC
, devname
);
1360 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1363 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1364 printk(KERN_WARNING
"CIFS: UNC Path does not "
1365 "begin with // or \\\\ \n");
1368 value
= strpbrk(vol
->UNC
+2, "/\\");
1372 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1376 if (vol
->UNCip
== NULL
)
1377 vol
->UNCip
= &vol
->UNC
[2];
1380 vol
->override_uid
= override_uid
;
1381 else if (override_uid
== 1)
1382 printk(KERN_NOTICE
"CIFS: ignoring forceuid mount option "
1383 "specified with no uid= option.\n");
1386 vol
->override_gid
= override_gid
;
1387 else if (override_gid
== 1)
1388 printk(KERN_NOTICE
"CIFS: ignoring forcegid mount option "
1389 "specified with no gid= option.\n");
1394 /** Returns true if srcaddr isn't specified and rhs isn't
1395 * specified, or if srcaddr is specified and
1396 * matches the IP address of the rhs argument.
1399 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1401 switch (srcaddr
->sa_family
) {
1403 return (rhs
->sa_family
== AF_UNSPEC
);
1405 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1406 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1407 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1410 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1411 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)&rhs
;
1412 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1416 return false; /* don't expect to be here */
1422 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1423 struct sockaddr
*srcaddr
)
1425 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
1426 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
1428 switch (addr
->sa_family
) {
1430 if (addr4
->sin_addr
.s_addr
!=
1431 server
->addr
.sockAddr
.sin_addr
.s_addr
)
1433 if (addr4
->sin_port
&&
1434 addr4
->sin_port
!= server
->addr
.sockAddr
.sin_port
)
1438 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
1439 &server
->addr
.sockAddr6
.sin6_addr
))
1441 if (addr6
->sin6_scope_id
!=
1442 server
->addr
.sockAddr6
.sin6_scope_id
)
1444 if (addr6
->sin6_port
&&
1445 addr6
->sin6_port
!= server
->addr
.sockAddr6
.sin6_port
)
1450 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
1457 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1459 unsigned int secFlags
;
1461 if (vol
->secFlg
& (~(CIFSSEC_MUST_SIGN
| CIFSSEC_MUST_SEAL
)))
1462 secFlags
= vol
->secFlg
;
1464 secFlags
= global_secflags
| vol
->secFlg
;
1466 switch (server
->secType
) {
1468 if (!(secFlags
& (CIFSSEC_MAY_LANMAN
|CIFSSEC_MAY_PLNTXT
)))
1472 if (!(secFlags
& CIFSSEC_MAY_NTLMV2
))
1476 if (!(secFlags
& CIFSSEC_MAY_NTLM
))
1480 if (!(secFlags
& CIFSSEC_MAY_KRB5
))
1484 if (!(secFlags
& CIFSSEC_MAY_NTLMSSP
))
1488 /* shouldn't happen */
1492 /* now check if signing mode is acceptible */
1493 if ((secFlags
& CIFSSEC_MAY_SIGN
) == 0 &&
1494 (server
->secMode
& SECMODE_SIGN_REQUIRED
))
1496 else if (((secFlags
& CIFSSEC_MUST_SIGN
) == CIFSSEC_MUST_SIGN
) &&
1498 (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
)) == 0)
1504 static struct TCP_Server_Info
*
1505 cifs_find_tcp_session(struct sockaddr
*addr
, struct smb_vol
*vol
)
1507 struct TCP_Server_Info
*server
;
1509 write_lock(&cifs_tcp_ses_lock
);
1510 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
1512 * the demux thread can exit on its own while still in CifsNew
1513 * so don't accept any sockets in that state. Since the
1514 * tcpStatus never changes back to CifsNew it's safe to check
1515 * for this without a lock.
1517 if (server
->tcpStatus
== CifsNew
)
1520 if (!match_address(server
, addr
,
1521 (struct sockaddr
*)&vol
->srcaddr
))
1524 if (!match_security(server
, vol
))
1527 ++server
->srv_count
;
1528 write_unlock(&cifs_tcp_ses_lock
);
1529 cFYI(1, "Existing tcp session with server found");
1532 write_unlock(&cifs_tcp_ses_lock
);
1537 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
1539 struct task_struct
*task
;
1541 write_lock(&cifs_tcp_ses_lock
);
1542 if (--server
->srv_count
> 0) {
1543 write_unlock(&cifs_tcp_ses_lock
);
1547 list_del_init(&server
->tcp_ses_list
);
1548 write_unlock(&cifs_tcp_ses_lock
);
1550 spin_lock(&GlobalMid_Lock
);
1551 server
->tcpStatus
= CifsExiting
;
1552 spin_unlock(&GlobalMid_Lock
);
1554 cifs_fscache_release_client_cookie(server
);
1556 task
= xchg(&server
->tsk
, NULL
);
1558 force_sig(SIGKILL
, task
);
1561 static struct TCP_Server_Info
*
1562 cifs_get_tcp_session(struct smb_vol
*volume_info
)
1564 struct TCP_Server_Info
*tcp_ses
= NULL
;
1565 struct sockaddr_storage addr
;
1566 struct sockaddr_in
*sin_server
= (struct sockaddr_in
*) &addr
;
1567 struct sockaddr_in6
*sin_server6
= (struct sockaddr_in6
*) &addr
;
1570 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
1572 cFYI(1, "UNC: %s ip: %s", volume_info
->UNC
, volume_info
->UNCip
);
1574 if (volume_info
->UNCip
&& volume_info
->UNC
) {
1575 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
1577 strlen(volume_info
->UNCip
),
1580 /* we failed translating address */
1584 } else if (volume_info
->UNCip
) {
1585 /* BB using ip addr as tcp_ses name to connect to the
1587 cERROR(1, "Connecting to DFS root not implemented yet");
1590 } else /* which tcp_sess DFS root would we conect to */ {
1591 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1592 "unc=//192.168.1.100/public) specified");
1597 /* see if we already have a matching tcp_ses */
1598 tcp_ses
= cifs_find_tcp_session((struct sockaddr
*)&addr
, volume_info
);
1602 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
1608 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
1609 if (IS_ERR(tcp_ses
->hostname
)) {
1610 rc
= PTR_ERR(tcp_ses
->hostname
);
1614 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
1615 tcp_ses
->noautotune
= volume_info
->noautotune
;
1616 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
1617 atomic_set(&tcp_ses
->inFlight
, 0);
1618 init_waitqueue_head(&tcp_ses
->response_q
);
1619 init_waitqueue_head(&tcp_ses
->request_q
);
1620 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
1621 mutex_init(&tcp_ses
->srv_mutex
);
1622 memcpy(tcp_ses
->workstation_RFC1001_name
,
1623 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
1624 memcpy(tcp_ses
->server_RFC1001_name
,
1625 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
1626 tcp_ses
->sequence_number
= 0;
1627 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
1628 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
1631 * at this point we are the only ones with the pointer
1632 * to the struct since the kernel thread not created yet
1633 * no need to spinlock this init of tcpStatus or srv_count
1635 tcp_ses
->tcpStatus
= CifsNew
;
1636 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
1637 sizeof(tcp_ses
->srcaddr
));
1638 ++tcp_ses
->srv_count
;
1640 if (addr
.ss_family
== AF_INET6
) {
1641 cFYI(1, "attempting ipv6 connect");
1642 /* BB should we allow ipv6 on port 139? */
1643 /* other OS never observed in Wild doing 139 with v6 */
1644 memcpy(&tcp_ses
->addr
.sockAddr6
, sin_server6
,
1645 sizeof(struct sockaddr_in6
));
1646 rc
= ipv6_connect(tcp_ses
);
1648 memcpy(&tcp_ses
->addr
.sockAddr
, sin_server
,
1649 sizeof(struct sockaddr_in
));
1650 rc
= ipv4_connect(tcp_ses
);
1653 cERROR(1, "Error connecting to socket. Aborting operation");
1658 * since we're in a cifs function already, we know that
1659 * this will succeed. No need for try_module_get().
1661 __module_get(THIS_MODULE
);
1662 tcp_ses
->tsk
= kthread_run((void *)(void *)cifs_demultiplex_thread
,
1664 if (IS_ERR(tcp_ses
->tsk
)) {
1665 rc
= PTR_ERR(tcp_ses
->tsk
);
1666 cERROR(1, "error %d create cifsd thread", rc
);
1667 module_put(THIS_MODULE
);
1671 /* thread spawned, put it on the list */
1672 write_lock(&cifs_tcp_ses_lock
);
1673 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
1674 write_unlock(&cifs_tcp_ses_lock
);
1676 cifs_fscache_get_client_cookie(tcp_ses
);
1682 if (!IS_ERR(tcp_ses
->hostname
))
1683 kfree(tcp_ses
->hostname
);
1684 if (tcp_ses
->ssocket
)
1685 sock_release(tcp_ses
->ssocket
);
1691 static struct cifsSesInfo
*
1692 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1694 struct cifsSesInfo
*ses
;
1696 write_lock(&cifs_tcp_ses_lock
);
1697 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
1698 switch (server
->secType
) {
1700 if (vol
->cred_uid
!= ses
->cred_uid
)
1704 /* anything else takes username/password */
1705 if (strncmp(ses
->userName
, vol
->username
,
1708 if (strlen(vol
->username
) != 0 &&
1709 ses
->password
!= NULL
&&
1710 strncmp(ses
->password
,
1711 vol
->password
? vol
->password
: "",
1716 write_unlock(&cifs_tcp_ses_lock
);
1719 write_unlock(&cifs_tcp_ses_lock
);
1724 cifs_put_smb_ses(struct cifsSesInfo
*ses
)
1727 struct TCP_Server_Info
*server
= ses
->server
;
1729 cFYI(1, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
1730 write_lock(&cifs_tcp_ses_lock
);
1731 if (--ses
->ses_count
> 0) {
1732 write_unlock(&cifs_tcp_ses_lock
);
1736 list_del_init(&ses
->smb_ses_list
);
1737 write_unlock(&cifs_tcp_ses_lock
);
1739 if (ses
->status
== CifsGood
) {
1741 CIFSSMBLogoff(xid
, ses
);
1745 cifs_put_tcp_session(server
);
1748 static struct cifsSesInfo
*
1749 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
1751 int rc
= -ENOMEM
, xid
;
1752 struct cifsSesInfo
*ses
;
1756 ses
= cifs_find_smb_ses(server
, volume_info
);
1758 cFYI(1, "Existing smb sess found (status=%d)", ses
->status
);
1760 mutex_lock(&ses
->session_mutex
);
1761 rc
= cifs_negotiate_protocol(xid
, ses
);
1763 mutex_unlock(&ses
->session_mutex
);
1764 /* problem -- put our ses reference */
1765 cifs_put_smb_ses(ses
);
1769 if (ses
->need_reconnect
) {
1770 cFYI(1, "Session needs reconnect");
1771 rc
= cifs_setup_session(xid
, ses
,
1772 volume_info
->local_nls
);
1774 mutex_unlock(&ses
->session_mutex
);
1775 /* problem -- put our reference */
1776 cifs_put_smb_ses(ses
);
1781 mutex_unlock(&ses
->session_mutex
);
1783 /* existing SMB ses has a server reference already */
1784 cifs_put_tcp_session(server
);
1789 cFYI(1, "Existing smb sess not found");
1790 ses
= sesInfoAlloc();
1796 /* new SMB session uses our server ref */
1797 ses
->server
= server
;
1798 if (server
->addr
.sockAddr6
.sin6_family
== AF_INET6
)
1799 sprintf(ses
->serverName
, "%pI6",
1800 &server
->addr
.sockAddr6
.sin6_addr
);
1802 sprintf(ses
->serverName
, "%pI4",
1803 &server
->addr
.sockAddr
.sin_addr
.s_addr
);
1805 if (volume_info
->username
)
1806 strncpy(ses
->userName
, volume_info
->username
,
1809 /* volume_info->password freed at unmount */
1810 if (volume_info
->password
) {
1811 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
1815 if (volume_info
->domainname
) {
1816 int len
= strlen(volume_info
->domainname
);
1817 ses
->domainName
= kmalloc(len
+ 1, GFP_KERNEL
);
1818 if (ses
->domainName
)
1819 strcpy(ses
->domainName
, volume_info
->domainname
);
1821 ses
->cred_uid
= volume_info
->cred_uid
;
1822 ses
->linux_uid
= volume_info
->linux_uid
;
1823 ses
->overrideSecFlg
= volume_info
->secFlg
;
1825 mutex_lock(&ses
->session_mutex
);
1826 rc
= cifs_negotiate_protocol(xid
, ses
);
1828 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
1829 mutex_unlock(&ses
->session_mutex
);
1833 /* success, put it on the list */
1834 write_lock(&cifs_tcp_ses_lock
);
1835 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
1836 write_unlock(&cifs_tcp_ses_lock
);
1847 static struct cifsTconInfo
*
1848 cifs_find_tcon(struct cifsSesInfo
*ses
, const char *unc
)
1850 struct list_head
*tmp
;
1851 struct cifsTconInfo
*tcon
;
1853 write_lock(&cifs_tcp_ses_lock
);
1854 list_for_each(tmp
, &ses
->tcon_list
) {
1855 tcon
= list_entry(tmp
, struct cifsTconInfo
, tcon_list
);
1856 if (tcon
->tidStatus
== CifsExiting
)
1858 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
1862 write_unlock(&cifs_tcp_ses_lock
);
1865 write_unlock(&cifs_tcp_ses_lock
);
1870 cifs_put_tcon(struct cifsTconInfo
*tcon
)
1873 struct cifsSesInfo
*ses
= tcon
->ses
;
1875 cFYI(1, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
1876 write_lock(&cifs_tcp_ses_lock
);
1877 if (--tcon
->tc_count
> 0) {
1878 write_unlock(&cifs_tcp_ses_lock
);
1882 list_del_init(&tcon
->tcon_list
);
1883 write_unlock(&cifs_tcp_ses_lock
);
1886 CIFSSMBTDis(xid
, tcon
);
1889 cifs_fscache_release_super_cookie(tcon
);
1891 cifs_put_smb_ses(ses
);
1894 static struct cifsTconInfo
*
1895 cifs_get_tcon(struct cifsSesInfo
*ses
, struct smb_vol
*volume_info
)
1898 struct cifsTconInfo
*tcon
;
1900 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
1902 cFYI(1, "Found match on UNC path");
1903 /* existing tcon already has a reference */
1904 cifs_put_smb_ses(ses
);
1905 if (tcon
->seal
!= volume_info
->seal
)
1906 cERROR(1, "transport encryption setting "
1907 "conflicts with existing tid");
1911 tcon
= tconInfoAlloc();
1918 if (volume_info
->password
) {
1919 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
1920 if (!tcon
->password
) {
1926 if (strchr(volume_info
->UNC
+ 3, '\\') == NULL
1927 && strchr(volume_info
->UNC
+ 3, '/') == NULL
) {
1928 cERROR(1, "Missing share name");
1933 /* BB Do we need to wrap session_mutex around
1934 * this TCon call and Unix SetFS as
1935 * we do on SessSetup and reconnect? */
1937 rc
= CIFSTCon(xid
, ses
, volume_info
->UNC
, tcon
, volume_info
->local_nls
);
1939 cFYI(1, "CIFS Tcon rc = %d", rc
);
1943 if (volume_info
->nodfs
) {
1944 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
1945 cFYI(1, "DFS disabled (%d)", tcon
->Flags
);
1947 tcon
->seal
= volume_info
->seal
;
1948 /* we can have only one retry value for a connection
1949 to a share so for resources mounted more than once
1950 to the same server share the last value passed in
1951 for the retry flag is used */
1952 tcon
->retry
= volume_info
->retry
;
1953 tcon
->nocase
= volume_info
->nocase
;
1954 tcon
->local_lease
= volume_info
->local_lease
;
1956 write_lock(&cifs_tcp_ses_lock
);
1957 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
1958 write_unlock(&cifs_tcp_ses_lock
);
1960 cifs_fscache_get_super_cookie(tcon
);
1971 get_dfs_path(int xid
, struct cifsSesInfo
*pSesInfo
, const char *old_path
,
1972 const struct nls_table
*nls_codepage
, unsigned int *pnum_referrals
,
1973 struct dfs_info3_param
**preferrals
, int remap
)
1978 *pnum_referrals
= 0;
1981 if (pSesInfo
->ipc_tid
== 0) {
1982 temp_unc
= kmalloc(2 /* for slashes */ +
1983 strnlen(pSesInfo
->serverName
,
1984 SERVER_NAME_LEN_WITH_NULL
* 2)
1985 + 1 + 4 /* slash IPC$ */ + 2,
1987 if (temp_unc
== NULL
)
1991 strcpy(temp_unc
+ 2, pSesInfo
->serverName
);
1992 strcpy(temp_unc
+ 2 + strlen(pSesInfo
->serverName
), "\\IPC$");
1993 rc
= CIFSTCon(xid
, pSesInfo
, temp_unc
, NULL
, nls_codepage
);
1994 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc
, pSesInfo
->ipc_tid
);
1998 rc
= CIFSGetDFSRefer(xid
, pSesInfo
, old_path
, preferrals
,
1999 pnum_referrals
, nls_codepage
, remap
);
2000 /* BB map targetUNCs to dfs_info3 structures, here or
2001 in CIFSGetDFSRefer BB */
2006 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2007 static struct lock_class_key cifs_key
[2];
2008 static struct lock_class_key cifs_slock_key
[2];
2011 cifs_reclassify_socket4(struct socket
*sock
)
2013 struct sock
*sk
= sock
->sk
;
2014 BUG_ON(sock_owned_by_user(sk
));
2015 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2016 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2020 cifs_reclassify_socket6(struct socket
*sock
)
2022 struct sock
*sk
= sock
->sk
;
2023 BUG_ON(sock_owned_by_user(sk
));
2024 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2025 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2029 cifs_reclassify_socket4(struct socket
*sock
)
2034 cifs_reclassify_socket6(struct socket
*sock
)
2039 /* See RFC1001 section 14 on representation of Netbios names */
2040 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2044 for (i
= 0, j
= 0; i
< (length
); i
++) {
2045 /* mask a nibble at a time and encode */
2046 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2047 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2054 bind_socket(struct TCP_Server_Info
*server
)
2057 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2058 /* Bind to the specified local IP address */
2059 struct socket
*socket
= server
->ssocket
;
2060 rc
= socket
->ops
->bind(socket
,
2061 (struct sockaddr
*) &server
->srcaddr
,
2062 sizeof(server
->srcaddr
));
2064 struct sockaddr_in
*saddr4
;
2065 struct sockaddr_in6
*saddr6
;
2066 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2067 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2068 if (saddr6
->sin6_family
== AF_INET6
)
2070 "Failed to bind to: %pI6c, error: %d\n",
2071 &saddr6
->sin6_addr
, rc
);
2074 "Failed to bind to: %pI4, error: %d\n",
2075 &saddr4
->sin_addr
.s_addr
, rc
);
2082 ipv4_connect(struct TCP_Server_Info
*server
)
2086 bool connected
= false;
2087 __be16 orig_port
= 0;
2088 struct socket
*socket
= server
->ssocket
;
2090 if (socket
== NULL
) {
2091 rc
= sock_create_kern(PF_INET
, SOCK_STREAM
,
2092 IPPROTO_TCP
, &socket
);
2094 cERROR(1, "Error %d creating socket", rc
);
2098 /* BB other socket options to set KEEPALIVE, NODELAY? */
2099 cFYI(1, "Socket created");
2100 server
->ssocket
= socket
;
2101 socket
->sk
->sk_allocation
= GFP_NOFS
;
2102 cifs_reclassify_socket4(socket
);
2105 rc
= bind_socket(server
);
2109 /* user overrode default port */
2110 if (server
->addr
.sockAddr
.sin_port
) {
2111 rc
= socket
->ops
->connect(socket
, (struct sockaddr
*)
2112 &server
->addr
.sockAddr
,
2113 sizeof(struct sockaddr_in
), 0);
2119 /* save original port so we can retry user specified port
2120 later if fall back ports fail this time */
2121 orig_port
= server
->addr
.sockAddr
.sin_port
;
2123 /* do not retry on the same port we just failed on */
2124 if (server
->addr
.sockAddr
.sin_port
!= htons(CIFS_PORT
)) {
2125 server
->addr
.sockAddr
.sin_port
= htons(CIFS_PORT
);
2126 rc
= socket
->ops
->connect(socket
,
2128 &server
->addr
.sockAddr
,
2129 sizeof(struct sockaddr_in
), 0);
2135 server
->addr
.sockAddr
.sin_port
= htons(RFC1001_PORT
);
2136 rc
= socket
->ops
->connect(socket
, (struct sockaddr
*)
2137 &server
->addr
.sockAddr
,
2138 sizeof(struct sockaddr_in
), 0);
2143 /* give up here - unless we want to retry on different
2144 protocol families some day */
2147 server
->addr
.sockAddr
.sin_port
= orig_port
;
2148 cFYI(1, "Error %d connecting to server via ipv4", rc
);
2149 sock_release(socket
);
2150 server
->ssocket
= NULL
;
2156 * Eventually check for other socket options to change from
2157 * the default. sock_setsockopt not used because it expects
2160 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
2161 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
2163 /* make the bufsizes depend on wsize/rsize and max requests */
2164 if (server
->noautotune
) {
2165 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
2166 socket
->sk
->sk_sndbuf
= 200 * 1024;
2167 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
2168 socket
->sk
->sk_rcvbuf
= 140 * 1024;
2171 if (server
->tcp_nodelay
) {
2173 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
2174 (char *)&val
, sizeof(val
));
2176 cFYI(1, "set TCP_NODELAY socket option error %d", rc
);
2179 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2180 socket
->sk
->sk_sndbuf
,
2181 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
2183 /* send RFC1001 sessinit */
2184 if (server
->addr
.sockAddr
.sin_port
== htons(RFC1001_PORT
)) {
2185 /* some servers require RFC1001 sessinit before sending
2186 negprot - BB check reconnection in case where second
2187 sessinit is sent but no second negprot */
2188 struct rfc1002_session_packet
*ses_init_buf
;
2189 struct smb_hdr
*smb_buf
;
2190 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2193 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2194 if (server
->server_RFC1001_name
&&
2195 server
->server_RFC1001_name
[0] != 0)
2196 rfc1002mangle(ses_init_buf
->trailer
.
2197 session_req
.called_name
,
2198 server
->server_RFC1001_name
,
2199 RFC1001_NAME_LEN_WITH_NULL
);
2201 rfc1002mangle(ses_init_buf
->trailer
.
2202 session_req
.called_name
,
2203 DEFAULT_CIFS_CALLED_NAME
,
2204 RFC1001_NAME_LEN_WITH_NULL
);
2206 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
2208 /* calling name ends in null (byte 16) from old smb
2210 if (server
->workstation_RFC1001_name
&&
2211 server
->workstation_RFC1001_name
[0] != 0)
2212 rfc1002mangle(ses_init_buf
->trailer
.
2213 session_req
.calling_name
,
2214 server
->workstation_RFC1001_name
,
2215 RFC1001_NAME_LEN_WITH_NULL
);
2217 rfc1002mangle(ses_init_buf
->trailer
.
2218 session_req
.calling_name
,
2220 RFC1001_NAME_LEN_WITH_NULL
);
2222 ses_init_buf
->trailer
.session_req
.scope1
= 0;
2223 ses_init_buf
->trailer
.session_req
.scope2
= 0;
2224 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
2225 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2226 smb_buf
->smb_buf_length
= 0x81000044;
2227 rc
= smb_send(server
, smb_buf
, 0x44);
2228 kfree(ses_init_buf
);
2229 msleep(1); /* RFC1001 layer in at least one server
2230 requires very short break before negprot
2231 presumably because not expecting negprot
2232 to follow so fast. This is a simple
2233 solution that works without
2234 complicating the code and causes no
2235 significant slowing down on mount
2236 for everyone else */
2238 /* else the negprot may still work without this
2239 even though malloc failed */
2247 ipv6_connect(struct TCP_Server_Info
*server
)
2251 bool connected
= false;
2252 __be16 orig_port
= 0;
2253 struct socket
*socket
= server
->ssocket
;
2255 if (socket
== NULL
) {
2256 rc
= sock_create_kern(PF_INET6
, SOCK_STREAM
,
2257 IPPROTO_TCP
, &socket
);
2259 cERROR(1, "Error %d creating ipv6 socket", rc
);
2264 /* BB other socket options to set KEEPALIVE, NODELAY? */
2265 cFYI(1, "ipv6 Socket created");
2266 server
->ssocket
= socket
;
2267 socket
->sk
->sk_allocation
= GFP_NOFS
;
2268 cifs_reclassify_socket6(socket
);
2271 rc
= bind_socket(server
);
2275 /* user overrode default port */
2276 if (server
->addr
.sockAddr6
.sin6_port
) {
2277 rc
= socket
->ops
->connect(socket
,
2278 (struct sockaddr
*) &server
->addr
.sockAddr6
,
2279 sizeof(struct sockaddr_in6
), 0);
2285 /* save original port so we can retry user specified port
2286 later if fall back ports fail this time */
2288 orig_port
= server
->addr
.sockAddr6
.sin6_port
;
2289 /* do not retry on the same port we just failed on */
2290 if (server
->addr
.sockAddr6
.sin6_port
!= htons(CIFS_PORT
)) {
2291 server
->addr
.sockAddr6
.sin6_port
= htons(CIFS_PORT
);
2292 rc
= socket
->ops
->connect(socket
, (struct sockaddr
*)
2293 &server
->addr
.sockAddr6
,
2294 sizeof(struct sockaddr_in6
), 0);
2300 server
->addr
.sockAddr6
.sin6_port
= htons(RFC1001_PORT
);
2301 rc
= socket
->ops
->connect(socket
, (struct sockaddr
*)
2302 &server
->addr
.sockAddr6
,
2303 sizeof(struct sockaddr_in6
), 0);
2308 /* give up here - unless we want to retry on different
2309 protocol families some day */
2312 server
->addr
.sockAddr6
.sin6_port
= orig_port
;
2313 cFYI(1, "Error %d connecting to server via ipv6", rc
);
2314 sock_release(socket
);
2315 server
->ssocket
= NULL
;
2320 * Eventually check for other socket options to change from
2321 * the default. sock_setsockopt not used because it expects
2324 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
2325 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
2327 if (server
->tcp_nodelay
) {
2329 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
2330 (char *)&val
, sizeof(val
));
2332 cFYI(1, "set TCP_NODELAY socket option error %d", rc
);
2335 server
->ssocket
= socket
;
2340 void reset_cifs_unix_caps(int xid
, struct cifsTconInfo
*tcon
,
2341 struct super_block
*sb
, struct smb_vol
*vol_info
)
2343 /* if we are reconnecting then should we check to see if
2344 * any requested capabilities changed locally e.g. via
2345 * remount but we can not do much about it here
2346 * if they have (even if we could detect it by the following)
2347 * Perhaps we could add a backpointer to array of sb from tcon
2348 * or if we change to make all sb to same share the same
2349 * sb as NFS - then we only have one backpointer to sb.
2350 * What if we wanted to mount the server share twice once with
2351 * and once without posixacls or posix paths? */
2352 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2354 if (vol_info
&& vol_info
->no_linux_ext
) {
2355 tcon
->fsUnixInfo
.Capability
= 0;
2356 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
2357 cFYI(1, "Linux protocol extensions disabled");
2359 } else if (vol_info
)
2360 tcon
->unix_ext
= 1; /* Unix Extensions supported */
2362 if (tcon
->unix_ext
== 0) {
2363 cFYI(1, "Unix extensions disabled so not set on reconnect");
2367 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
2368 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
2370 /* check for reconnect case in which we do not
2371 want to change the mount behavior if we can avoid it */
2372 if (vol_info
== NULL
) {
2373 /* turn off POSIX ACL and PATHNAMES if not set
2374 originally at mount time */
2375 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
2376 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
2377 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
2378 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
2379 cERROR(1, "POSIXPATH support change");
2380 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
2381 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
2382 cERROR(1, "possible reconnect error");
2383 cERROR(1, "server disabled POSIX path support");
2387 cap
&= CIFS_UNIX_CAP_MASK
;
2388 if (vol_info
&& vol_info
->no_psx_acl
)
2389 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
2390 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
2391 cFYI(1, "negotiated posix acl support");
2393 sb
->s_flags
|= MS_POSIXACL
;
2396 if (vol_info
&& vol_info
->posix_paths
== 0)
2397 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
2398 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2399 cFYI(1, "negotiate posix pathnames");
2401 CIFS_SB(sb
)->mnt_cifs_flags
|=
2402 CIFS_MOUNT_POSIX_PATHS
;
2405 /* We might be setting the path sep back to a different
2406 form if we are reconnecting and the server switched its
2407 posix path capability for this share */
2408 if (sb
&& (CIFS_SB(sb
)->prepathlen
> 0))
2409 CIFS_SB(sb
)->prepath
[0] = CIFS_DIR_SEP(CIFS_SB(sb
));
2411 if (sb
&& (CIFS_SB(sb
)->rsize
> 127 * 1024)) {
2412 if ((cap
& CIFS_UNIX_LARGE_READ_CAP
) == 0) {
2413 CIFS_SB(sb
)->rsize
= 127 * 1024;
2414 cFYI(DBG2
, "larger reads not supported by srv");
2419 cFYI(1, "Negotiate caps 0x%x", (int)cap
);
2420 #ifdef CONFIG_CIFS_DEBUG2
2421 if (cap
& CIFS_UNIX_FCNTL_CAP
)
2422 cFYI(1, "FCNTL cap");
2423 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
2424 cFYI(1, "EXTATTR cap");
2425 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
2426 cFYI(1, "POSIX path cap");
2427 if (cap
& CIFS_UNIX_XATTR_CAP
)
2428 cFYI(1, "XATTR cap");
2429 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
2430 cFYI(1, "POSIX ACL cap");
2431 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
2432 cFYI(1, "very large read cap");
2433 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
2434 cFYI(1, "very large write cap");
2435 #endif /* CIFS_DEBUG2 */
2436 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
2437 if (vol_info
== NULL
) {
2438 cFYI(1, "resetting capabilities failed");
2440 cERROR(1, "Negotiating Unix capabilities "
2441 "with the server failed. Consider "
2442 "mounting with the Unix Extensions\n"
2443 "disabled, if problems are found, "
2444 "by specifying the nounix mount "
2452 convert_delimiter(char *path
, char delim
)
2465 for (i
= 0; path
[i
] != '\0'; i
++) {
2466 if (path
[i
] == old_delim
)
2471 static void setup_cifs_sb(struct smb_vol
*pvolume_info
,
2472 struct cifs_sb_info
*cifs_sb
)
2474 if (pvolume_info
->rsize
> CIFSMaxBufSize
) {
2475 cERROR(1, "rsize %d too large, using MaxBufSize",
2476 pvolume_info
->rsize
);
2477 cifs_sb
->rsize
= CIFSMaxBufSize
;
2478 } else if ((pvolume_info
->rsize
) &&
2479 (pvolume_info
->rsize
<= CIFSMaxBufSize
))
2480 cifs_sb
->rsize
= pvolume_info
->rsize
;
2482 cifs_sb
->rsize
= CIFSMaxBufSize
;
2484 if (pvolume_info
->wsize
> PAGEVEC_SIZE
* PAGE_CACHE_SIZE
) {
2485 cERROR(1, "wsize %d too large, using 4096 instead",
2486 pvolume_info
->wsize
);
2487 cifs_sb
->wsize
= 4096;
2488 } else if (pvolume_info
->wsize
)
2489 cifs_sb
->wsize
= pvolume_info
->wsize
;
2491 cifs_sb
->wsize
= min_t(const int,
2492 PAGEVEC_SIZE
* PAGE_CACHE_SIZE
,
2494 /* old default of CIFSMaxBufSize was too small now
2495 that SMB Write2 can send multiple pages in kvec.
2496 RFC1001 does not describe what happens when frame
2497 bigger than 128K is sent so use that as max in
2498 conjunction with 52K kvec constraint on arch with 4K
2501 if (cifs_sb
->rsize
< 2048) {
2502 cifs_sb
->rsize
= 2048;
2503 /* Windows ME may prefer this */
2504 cFYI(1, "readsize set to minimum: 2048");
2506 /* calculate prepath */
2507 cifs_sb
->prepath
= pvolume_info
->prepath
;
2508 if (cifs_sb
->prepath
) {
2509 cifs_sb
->prepathlen
= strlen(cifs_sb
->prepath
);
2510 /* we can not convert the / to \ in the path
2511 separators in the prefixpath yet because we do not
2512 know (until reset_cifs_unix_caps is called later)
2513 whether POSIX PATH CAP is available. We normalize
2514 the / to \ after reset_cifs_unix_caps is called */
2515 pvolume_info
->prepath
= NULL
;
2517 cifs_sb
->prepathlen
= 0;
2518 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
2519 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
2520 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
2521 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
2522 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2523 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
2525 if (pvolume_info
->noperm
)
2526 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
2527 if (pvolume_info
->setuids
)
2528 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
2529 if (pvolume_info
->server_ino
)
2530 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
2531 if (pvolume_info
->remap
)
2532 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
2533 if (pvolume_info
->no_xattr
)
2534 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
2535 if (pvolume_info
->sfu_emul
)
2536 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
2537 if (pvolume_info
->nobrl
)
2538 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
2539 if (pvolume_info
->nostrictsync
)
2540 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
2541 if (pvolume_info
->mand_lock
)
2542 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
2543 if (pvolume_info
->cifs_acl
)
2544 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
2545 if (pvolume_info
->override_uid
)
2546 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
2547 if (pvolume_info
->override_gid
)
2548 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
2549 if (pvolume_info
->dynperm
)
2550 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
2551 if (pvolume_info
->fsc
)
2552 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
2553 if (pvolume_info
->direct_io
) {
2554 cFYI(1, "mounting share using direct i/o");
2555 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
2558 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
2559 cERROR(1, "mount option dynperm ignored if cifsacl "
2560 "mount option supported");
2564 is_path_accessible(int xid
, struct cifsTconInfo
*tcon
,
2565 struct cifs_sb_info
*cifs_sb
, const char *full_path
)
2568 FILE_ALL_INFO
*pfile_info
;
2570 pfile_info
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
2571 if (pfile_info
== NULL
)
2574 rc
= CIFSSMBQPathInfo(xid
, tcon
, full_path
, pfile_info
,
2575 0 /* not legacy */, cifs_sb
->local_nls
,
2576 cifs_sb
->mnt_cifs_flags
&
2577 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2583 cleanup_volume_info(struct smb_vol
**pvolume_info
)
2585 struct smb_vol
*volume_info
;
2587 if (!pvolume_info
|| !*pvolume_info
)
2590 volume_info
= *pvolume_info
;
2591 kzfree(volume_info
->password
);
2592 kfree(volume_info
->UNC
);
2593 kfree(volume_info
->prepath
);
2595 *pvolume_info
= NULL
;
2599 #ifdef CONFIG_CIFS_DFS_UPCALL
2600 /* build_path_to_root returns full path to root when
2601 * we do not have an exiting connection (tcon) */
2603 build_unc_path_to_root(const struct smb_vol
*volume_info
,
2604 const struct cifs_sb_info
*cifs_sb
)
2608 int unc_len
= strnlen(volume_info
->UNC
, MAX_TREE_SIZE
+ 1);
2609 full_path
= kmalloc(unc_len
+ cifs_sb
->prepathlen
+ 1, GFP_KERNEL
);
2610 if (full_path
== NULL
)
2611 return ERR_PTR(-ENOMEM
);
2613 strncpy(full_path
, volume_info
->UNC
, unc_len
);
2614 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
2616 for (i
= 0; i
< unc_len
; i
++) {
2617 if (full_path
[i
] == '\\')
2622 if (cifs_sb
->prepathlen
)
2623 strncpy(full_path
+ unc_len
, cifs_sb
->prepath
,
2624 cifs_sb
->prepathlen
);
2626 full_path
[unc_len
+ cifs_sb
->prepathlen
] = 0; /* add trailing null */
2632 cifs_mount(struct super_block
*sb
, struct cifs_sb_info
*cifs_sb
,
2633 char *mount_data_global
, const char *devname
)
2637 struct smb_vol
*volume_info
;
2638 struct cifsSesInfo
*pSesInfo
;
2639 struct cifsTconInfo
*tcon
;
2640 struct TCP_Server_Info
*srvTcp
;
2642 char *mount_data
= mount_data_global
;
2643 #ifdef CONFIG_CIFS_DFS_UPCALL
2644 struct dfs_info3_param
*referrals
= NULL
;
2645 unsigned int num_referrals
= 0;
2646 int referral_walks_count
= 0;
2657 volume_info
= kzalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
2663 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
)) {
2668 if (volume_info
->nullauth
) {
2669 cFYI(1, "null user");
2670 volume_info
->username
= "";
2671 } else if (volume_info
->username
) {
2672 /* BB fixme parse for domain name here */
2673 cFYI(1, "Username: %s", volume_info
->username
);
2675 cifserror("No username specified");
2676 /* In userspace mount helper we can get user name from alternate
2677 locations such as env variables and files on disk */
2682 /* this is needed for ASCII cp to Unicode converts */
2683 if (volume_info
->iocharset
== NULL
) {
2684 /* load_nls_default cannot return null */
2685 volume_info
->local_nls
= load_nls_default();
2687 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
2688 if (volume_info
->local_nls
== NULL
) {
2689 cERROR(1, "CIFS mount error: iocharset %s not found",
2690 volume_info
->iocharset
);
2695 cifs_sb
->local_nls
= volume_info
->local_nls
;
2697 /* get a reference to a tcp session */
2698 srvTcp
= cifs_get_tcp_session(volume_info
);
2699 if (IS_ERR(srvTcp
)) {
2700 rc
= PTR_ERR(srvTcp
);
2704 /* get a reference to a SMB session */
2705 pSesInfo
= cifs_get_smb_ses(srvTcp
, volume_info
);
2706 if (IS_ERR(pSesInfo
)) {
2707 rc
= PTR_ERR(pSesInfo
);
2709 goto mount_fail_check
;
2712 setup_cifs_sb(volume_info
, cifs_sb
);
2713 if (pSesInfo
->capabilities
& CAP_LARGE_FILES
)
2714 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
2716 sb
->s_maxbytes
= MAX_NON_LFS
;
2718 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2719 sb
->s_time_gran
= 100;
2721 /* search for existing tcon to this server share */
2722 tcon
= cifs_get_tcon(pSesInfo
, volume_info
);
2726 goto remote_path_check
;
2729 cifs_sb
->tcon
= tcon
;
2731 /* do not care if following two calls succeed - informational */
2733 CIFSSMBQFSDeviceInfo(xid
, tcon
);
2734 CIFSSMBQFSAttributeInfo(xid
, tcon
);
2737 /* tell server which Unix caps we support */
2738 if (tcon
->ses
->capabilities
& CAP_UNIX
)
2739 /* reset of caps checks mount to see if unix extensions
2740 disabled for just this mount */
2741 reset_cifs_unix_caps(xid
, tcon
, sb
, volume_info
);
2743 tcon
->unix_ext
= 0; /* server does not support them */
2745 /* convert forward to back slashes in prepath here if needed */
2746 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) == 0)
2747 convert_delimiter(cifs_sb
->prepath
, CIFS_DIR_SEP(cifs_sb
));
2749 if ((tcon
->unix_ext
== 0) && (cifs_sb
->rsize
> (1024 * 127))) {
2750 cifs_sb
->rsize
= 1024 * 127;
2751 cFYI(DBG2
, "no very large read support, rsize now 127K");
2753 if (!(tcon
->ses
->capabilities
& CAP_LARGE_WRITE_X
))
2754 cifs_sb
->wsize
= min(cifs_sb
->wsize
,
2755 (tcon
->ses
->server
->maxBuf
- MAX_CIFS_HDR_SIZE
));
2756 if (!(tcon
->ses
->capabilities
& CAP_LARGE_READ_X
))
2757 cifs_sb
->rsize
= min(cifs_sb
->rsize
,
2758 (tcon
->ses
->server
->maxBuf
- MAX_CIFS_HDR_SIZE
));
2761 /* check if a whole path (including prepath) is not remote */
2762 if (!rc
&& cifs_sb
->prepathlen
&& tcon
) {
2763 /* build_path_to_root works only when we have a valid tcon */
2764 full_path
= cifs_build_path_to_root(cifs_sb
);
2765 if (full_path
== NULL
) {
2767 goto mount_fail_check
;
2769 rc
= is_path_accessible(xid
, tcon
, cifs_sb
, full_path
);
2770 if (rc
!= -EREMOTE
) {
2772 goto mount_fail_check
;
2777 /* get referral if needed */
2778 if (rc
== -EREMOTE
) {
2779 #ifdef CONFIG_CIFS_DFS_UPCALL
2780 if (referral_walks_count
> MAX_NESTED_LINKS
) {
2782 * BB: when we implement proper loop detection,
2783 * we will remove this check. But now we need it
2784 * to prevent an indefinite loop if 'DFS tree' is
2785 * misconfigured (i.e. has loops).
2788 goto mount_fail_check
;
2790 /* convert forward to back slashes in prepath here if needed */
2791 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) == 0)
2792 convert_delimiter(cifs_sb
->prepath
,
2793 CIFS_DIR_SEP(cifs_sb
));
2794 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
2795 if (IS_ERR(full_path
)) {
2796 rc
= PTR_ERR(full_path
);
2797 goto mount_fail_check
;
2800 cFYI(1, "Getting referral for: %s", full_path
);
2801 rc
= get_dfs_path(xid
, pSesInfo
, full_path
+ 1,
2802 cifs_sb
->local_nls
, &num_referrals
, &referrals
,
2803 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
2804 if (!rc
&& num_referrals
> 0) {
2805 char *fake_devname
= NULL
;
2807 if (mount_data
!= mount_data_global
)
2810 mount_data
= cifs_compose_mount_options(
2811 cifs_sb
->mountdata
, full_path
+ 1,
2812 referrals
, &fake_devname
);
2814 free_dfs_info_array(referrals
, num_referrals
);
2815 kfree(fake_devname
);
2818 if (IS_ERR(mount_data
)) {
2819 rc
= PTR_ERR(mount_data
);
2821 goto mount_fail_check
;
2825 cifs_put_tcon(tcon
);
2827 cifs_put_smb_ses(pSesInfo
);
2829 cleanup_volume_info(&volume_info
);
2830 referral_walks_count
++;
2832 goto try_mount_again
;
2834 #else /* No DFS support, return error on mount */
2840 /* on error free sesinfo and tcon struct if needed */
2842 if (mount_data
!= mount_data_global
)
2844 /* If find_unc succeeded then rc == 0 so we can not end */
2845 /* up accidently freeing someone elses tcon struct */
2847 cifs_put_tcon(tcon
);
2849 cifs_put_smb_ses(pSesInfo
);
2851 cifs_put_tcp_session(srvTcp
);
2855 /* volume_info->password is freed above when existing session found
2856 (in which case it is not needed anymore) but when new sesion is created
2857 the password ptr is put in the new session structure (in which case the
2858 password will be freed at unmount time) */
2860 /* zero out password before freeing */
2861 cleanup_volume_info(&volume_info
);
2867 CIFSTCon(unsigned int xid
, struct cifsSesInfo
*ses
,
2868 const char *tree
, struct cifsTconInfo
*tcon
,
2869 const struct nls_table
*nls_codepage
)
2871 struct smb_hdr
*smb_buffer
;
2872 struct smb_hdr
*smb_buffer_response
;
2875 unsigned char *bcc_ptr
;
2877 int length
, bytes_left
;
2883 smb_buffer
= cifs_buf_get();
2884 if (smb_buffer
== NULL
)
2887 smb_buffer_response
= smb_buffer
;
2889 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
2890 NULL
/*no tid */ , 4 /*wct */ );
2892 smb_buffer
->Mid
= GetNextMid(ses
->server
);
2893 smb_buffer
->Uid
= ses
->Suid
;
2894 pSMB
= (TCONX_REQ
*) smb_buffer
;
2895 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
2897 pSMB
->AndXCommand
= 0xFF;
2898 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
2899 bcc_ptr
= &pSMB
->Password
[0];
2900 if ((ses
->server
->secMode
) & SECMODE_USER
) {
2901 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
2902 *bcc_ptr
= 0; /* password is null byte */
2903 bcc_ptr
++; /* skip password */
2904 /* already aligned so no need to do it below */
2906 pSMB
->PasswordLength
= cpu_to_le16(CIFS_SESS_KEY_SIZE
);
2907 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2908 specified as required (when that support is added to
2909 the vfs in the future) as only NTLM or the much
2910 weaker LANMAN (which we do not send by default) is accepted
2911 by Samba (not sure whether other servers allow
2912 NTLMv2 password here) */
2913 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2914 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
2915 (ses
->server
->secType
== LANMAN
))
2916 calc_lanman_hash(tcon
->password
, ses
->server
->cryptKey
,
2917 ses
->server
->secMode
&
2918 SECMODE_PW_ENCRYPT
? true : false,
2921 #endif /* CIFS_WEAK_PW_HASH */
2922 SMBNTencrypt(tcon
->password
, ses
->server
->cryptKey
,
2925 bcc_ptr
+= CIFS_SESS_KEY_SIZE
;
2926 if (ses
->capabilities
& CAP_UNICODE
) {
2927 /* must align unicode strings */
2928 *bcc_ptr
= 0; /* null byte password */
2933 if (ses
->server
->secMode
&
2934 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
2935 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
2937 if (ses
->capabilities
& CAP_STATUS32
) {
2938 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
2940 if (ses
->capabilities
& CAP_DFS
) {
2941 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
2943 if (ses
->capabilities
& CAP_UNICODE
) {
2944 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
2946 cifs_strtoUCS((__le16
*) bcc_ptr
, tree
,
2947 6 /* max utf8 char length in bytes */ *
2948 (/* server len*/ + 256 /* share len */), nls_codepage
);
2949 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
2950 bcc_ptr
+= 2; /* skip trailing null */
2951 } else { /* ASCII */
2952 strcpy(bcc_ptr
, tree
);
2953 bcc_ptr
+= strlen(tree
) + 1;
2955 strcpy(bcc_ptr
, "?????");
2956 bcc_ptr
+= strlen("?????");
2958 count
= bcc_ptr
- &pSMB
->Password
[0];
2959 pSMB
->hdr
.smb_buf_length
+= count
;
2960 pSMB
->ByteCount
= cpu_to_le16(count
);
2962 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
2965 /* above now done in SendReceive */
2966 if ((rc
== 0) && (tcon
!= NULL
)) {
2969 tcon
->tidStatus
= CifsGood
;
2970 tcon
->need_reconnect
= false;
2971 tcon
->tid
= smb_buffer_response
->Tid
;
2972 bcc_ptr
= pByteArea(smb_buffer_response
);
2973 bytes_left
= BCC(smb_buffer_response
);
2974 length
= strnlen(bcc_ptr
, bytes_left
- 2);
2975 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
2981 /* skip service field (NB: this field is always ASCII) */
2983 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
2984 (bcc_ptr
[2] == 'C')) {
2985 cFYI(1, "IPC connection");
2988 } else if (length
== 2) {
2989 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
2990 /* the most common case */
2991 cFYI(1, "disk share connection");
2994 bcc_ptr
+= length
+ 1;
2995 bytes_left
-= (length
+ 1);
2996 strncpy(tcon
->treeName
, tree
, MAX_TREE_SIZE
);
2998 /* mostly informational -- no need to fail on error here */
2999 kfree(tcon
->nativeFileSystem
);
3000 tcon
->nativeFileSystem
= cifs_strndup_from_ucs(bcc_ptr
,
3001 bytes_left
, is_unicode
,
3004 cFYI(1, "nativeFileSystem=%s", tcon
->nativeFileSystem
);
3006 if ((smb_buffer_response
->WordCount
== 3) ||
3007 (smb_buffer_response
->WordCount
== 7))
3008 /* field is in same location */
3009 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3012 cFYI(1, "Tcon flags: 0x%x ", tcon
->Flags
);
3013 } else if ((rc
== 0) && tcon
== NULL
) {
3014 /* all we need to save for IPC$ connection */
3015 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3018 cifs_buf_release(smb_buffer
);
3023 cifs_umount(struct super_block
*sb
, struct cifs_sb_info
*cifs_sb
)
3029 cifs_put_tcon(cifs_sb
->tcon
);
3031 cifs_sb
->tcon
= NULL
;
3032 tmp
= cifs_sb
->prepath
;
3033 cifs_sb
->prepathlen
= 0;
3034 cifs_sb
->prepath
= NULL
;
3040 int cifs_negotiate_protocol(unsigned int xid
, struct cifsSesInfo
*ses
)
3043 struct TCP_Server_Info
*server
= ses
->server
;
3045 /* only send once per connect */
3046 if (server
->maxBuf
!= 0)
3049 rc
= CIFSSMBNegotiate(xid
, ses
);
3050 if (rc
== -EAGAIN
) {
3051 /* retry only once on 1st time connection */
3052 rc
= CIFSSMBNegotiate(xid
, ses
);
3057 spin_lock(&GlobalMid_Lock
);
3058 if (server
->tcpStatus
!= CifsExiting
)
3059 server
->tcpStatus
= CifsGood
;
3062 spin_unlock(&GlobalMid_Lock
);
3070 int cifs_setup_session(unsigned int xid
, struct cifsSesInfo
*ses
,
3071 struct nls_table
*nls_info
)
3074 struct TCP_Server_Info
*server
= ses
->server
;
3077 ses
->capabilities
= server
->capabilities
;
3078 if (linuxExtEnabled
== 0)
3079 ses
->capabilities
&= (~CAP_UNIX
);
3081 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3082 server
->secMode
, server
->capabilities
, server
->timeAdj
);
3084 rc
= CIFS_SessSetup(xid
, ses
, nls_info
);
3086 cERROR(1, "Send error in SessSetup = %d", rc
);
3088 cFYI(1, "CIFS Session Established successfully");
3089 spin_lock(&GlobalMid_Lock
);
3090 ses
->status
= CifsGood
;
3091 ses
->need_reconnect
= false;
3092 spin_unlock(&GlobalMid_Lock
);