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>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
43 #include <linux/parser.h>
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
53 #include "rfc1002pdu.h"
57 #define RFC1001_PORT 139
59 /* SMB echo "timeout" -- FIXME: tunable? */
60 #define SMB_ECHO_INTERVAL (60 * HZ)
62 extern mempool_t
*cifs_req_poolp
;
64 /* FIXME: should these be tunable? */
65 #define TLINK_ERROR_EXPIRE (1 * HZ)
66 #define TLINK_IDLE_EXPIRE (600 * HZ)
70 /* Mount options that take no arguments */
71 Opt_user_xattr
, Opt_nouser_xattr
,
72 Opt_forceuid
, Opt_noforceuid
,
73 Opt_noblocksend
, Opt_noautotune
,
74 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
,
75 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
76 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
77 Opt_noposixpaths
, Opt_nounix
,
80 Opt_forcemandatorylock
, Opt_setuids
,
81 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
82 Opt_nohard
, Opt_nosoft
,
84 Opt_nostrictsync
, Opt_strictsync
,
85 Opt_serverino
, Opt_noserverino
,
86 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
87 Opt_acl
, Opt_noacl
, Opt_locallease
,
88 Opt_sign
, Opt_seal
, Opt_direct
,
89 Opt_strictcache
, Opt_noac
,
90 Opt_fsc
, Opt_mfsymlinks
,
91 Opt_multiuser
, Opt_sloppy
,
93 /* Mount options which take numeric value */
94 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
95 Opt_cruid
, Opt_gid
, Opt_file_mode
,
96 Opt_dirmode
, Opt_port
,
97 Opt_rsize
, Opt_wsize
, Opt_actimeo
,
99 /* Mount options which take string value */
100 Opt_user
, Opt_pass
, Opt_ip
,
102 Opt_srcaddr
, Opt_prefixpath
,
103 Opt_iocharset
, Opt_sockopt
,
104 Opt_netbiosname
, Opt_servern
,
107 /* Mount options to be ignored */
110 /* Options which could be blank */
118 static const match_table_t cifs_mount_option_tokens
= {
120 { Opt_user_xattr
, "user_xattr" },
121 { Opt_nouser_xattr
, "nouser_xattr" },
122 { Opt_forceuid
, "forceuid" },
123 { Opt_noforceuid
, "noforceuid" },
124 { Opt_noblocksend
, "noblocksend" },
125 { Opt_noautotune
, "noautotune" },
126 { Opt_hard
, "hard" },
127 { Opt_soft
, "soft" },
128 { Opt_perm
, "perm" },
129 { Opt_noperm
, "noperm" },
130 { Opt_mapchars
, "mapchars" },
131 { Opt_nomapchars
, "nomapchars" },
133 { Opt_nosfu
, "nosfu" },
134 { Opt_nodfs
, "nodfs" },
135 { Opt_posixpaths
, "posixpaths" },
136 { Opt_noposixpaths
, "noposixpaths" },
137 { Opt_nounix
, "nounix" },
138 { Opt_nounix
, "nolinux" },
139 { Opt_nocase
, "nocase" },
140 { Opt_nocase
, "ignorecase" },
142 { Opt_nobrl
, "nobrl" },
143 { Opt_nobrl
, "nolock" },
144 { Opt_forcemandatorylock
, "forcemandatorylock" },
145 { Opt_forcemandatorylock
, "forcemand" },
146 { Opt_setuids
, "setuids" },
147 { Opt_nosetuids
, "nosetuids" },
148 { Opt_dynperm
, "dynperm" },
149 { Opt_nodynperm
, "nodynperm" },
150 { Opt_nohard
, "nohard" },
151 { Opt_nosoft
, "nosoft" },
152 { Opt_nointr
, "nointr" },
153 { Opt_intr
, "intr" },
154 { Opt_nostrictsync
, "nostrictsync" },
155 { Opt_strictsync
, "strictsync" },
156 { Opt_serverino
, "serverino" },
157 { Opt_noserverino
, "noserverino" },
158 { Opt_rwpidforward
, "rwpidforward" },
159 { Opt_cifsacl
, "cifsacl" },
160 { Opt_nocifsacl
, "nocifsacl" },
162 { Opt_noacl
, "noacl" },
163 { Opt_locallease
, "locallease" },
164 { Opt_sign
, "sign" },
165 { Opt_seal
, "seal" },
166 { Opt_direct
, "direct" },
167 { Opt_direct
, "forceddirectio" },
168 { Opt_strictcache
, "strictcache" },
169 { Opt_noac
, "noac" },
171 { Opt_mfsymlinks
, "mfsymlinks" },
172 { Opt_multiuser
, "multiuser" },
173 { Opt_sloppy
, "sloppy" },
175 { Opt_backupuid
, "backupuid=%s" },
176 { Opt_backupgid
, "backupgid=%s" },
177 { Opt_uid
, "uid=%s" },
178 { Opt_cruid
, "cruid=%s" },
179 { Opt_gid
, "gid=%s" },
180 { Opt_file_mode
, "file_mode=%s" },
181 { Opt_dirmode
, "dirmode=%s" },
182 { Opt_dirmode
, "dir_mode=%s" },
183 { Opt_port
, "port=%s" },
184 { Opt_rsize
, "rsize=%s" },
185 { Opt_wsize
, "wsize=%s" },
186 { Opt_actimeo
, "actimeo=%s" },
188 { Opt_blank_user
, "user=" },
189 { Opt_blank_user
, "username=" },
190 { Opt_user
, "user=%s" },
191 { Opt_user
, "username=%s" },
192 { Opt_blank_pass
, "pass=" },
193 { Opt_pass
, "pass=%s" },
194 { Opt_pass
, "password=%s" },
195 { Opt_blank_ip
, "ip=" },
196 { Opt_blank_ip
, "addr=" },
198 { Opt_ip
, "addr=%s" },
199 { Opt_unc
, "unc=%s" },
200 { Opt_unc
, "target=%s" },
201 { Opt_unc
, "path=%s" },
202 { Opt_domain
, "dom=%s" },
203 { Opt_domain
, "domain=%s" },
204 { Opt_domain
, "workgroup=%s" },
205 { Opt_srcaddr
, "srcaddr=%s" },
206 { Opt_prefixpath
, "prefixpath=%s" },
207 { Opt_iocharset
, "iocharset=%s" },
208 { Opt_sockopt
, "sockopt=%s" },
209 { Opt_netbiosname
, "netbiosname=%s" },
210 { Opt_servern
, "servern=%s" },
211 { Opt_ver
, "ver=%s" },
212 { Opt_ver
, "vers=%s" },
213 { Opt_ver
, "version=%s" },
214 { Opt_sec
, "sec=%s" },
216 { Opt_ignore
, "cred" },
217 { Opt_ignore
, "credentials" },
218 { Opt_ignore
, "cred=%s" },
219 { Opt_ignore
, "credentials=%s" },
220 { Opt_ignore
, "guest" },
221 { Opt_ignore
, "rw" },
222 { Opt_ignore
, "ro" },
223 { Opt_ignore
, "suid" },
224 { Opt_ignore
, "nosuid" },
225 { Opt_ignore
, "exec" },
226 { Opt_ignore
, "noexec" },
227 { Opt_ignore
, "nodev" },
228 { Opt_ignore
, "noauto" },
229 { Opt_ignore
, "dev" },
230 { Opt_ignore
, "mand" },
231 { Opt_ignore
, "nomand" },
232 { Opt_ignore
, "_netdev" },
238 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
239 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
240 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2i
,
241 Opt_sec_nontlm
, Opt_sec_lanman
,
247 static const match_table_t cifs_secflavor_tokens
= {
248 { Opt_sec_krb5
, "krb5" },
249 { Opt_sec_krb5i
, "krb5i" },
250 { Opt_sec_krb5p
, "krb5p" },
251 { Opt_sec_ntlmsspi
, "ntlmsspi" },
252 { Opt_sec_ntlmssp
, "ntlmssp" },
253 { Opt_ntlm
, "ntlm" },
254 { Opt_sec_ntlmi
, "ntlmi" },
255 { Opt_sec_ntlmv2i
, "ntlmv2i" },
256 { Opt_sec_nontlm
, "nontlm" },
257 { Opt_sec_lanman
, "lanman" },
258 { Opt_sec_none
, "none" },
260 { Opt_sec_err
, NULL
}
263 static int ip_connect(struct TCP_Server_Info
*server
);
264 static int generic_ip_connect(struct TCP_Server_Info
*server
);
265 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
266 static void cifs_prune_tlinks(struct work_struct
*work
);
267 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
268 const char *devname
);
271 * cifs tcp session reconnection
273 * mark tcp session as reconnecting so temporarily locked
274 * mark all smb sessions as reconnecting for tcp session
275 * reconnect tcp session
276 * wake up waiters on reconnection? - (not needed currently)
279 cifs_reconnect(struct TCP_Server_Info
*server
)
282 struct list_head
*tmp
, *tmp2
;
283 struct cifs_ses
*ses
;
284 struct cifs_tcon
*tcon
;
285 struct mid_q_entry
*mid_entry
;
286 struct list_head retry_list
;
288 spin_lock(&GlobalMid_Lock
);
289 if (server
->tcpStatus
== CifsExiting
) {
290 /* the demux thread will exit normally
291 next time through the loop */
292 spin_unlock(&GlobalMid_Lock
);
295 server
->tcpStatus
= CifsNeedReconnect
;
296 spin_unlock(&GlobalMid_Lock
);
299 cFYI(1, "Reconnecting tcp session");
301 /* before reconnecting the tcp session, mark the smb session (uid)
302 and the tid bad so they are not used until reconnected */
303 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__
);
304 spin_lock(&cifs_tcp_ses_lock
);
305 list_for_each(tmp
, &server
->smb_ses_list
) {
306 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
307 ses
->need_reconnect
= true;
309 list_for_each(tmp2
, &ses
->tcon_list
) {
310 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
311 tcon
->need_reconnect
= true;
314 spin_unlock(&cifs_tcp_ses_lock
);
316 /* do not want to be sending data on a socket we are freeing */
317 cFYI(1, "%s: tearing down socket", __func__
);
318 mutex_lock(&server
->srv_mutex
);
319 if (server
->ssocket
) {
320 cFYI(1, "State: 0x%x Flags: 0x%lx", server
->ssocket
->state
,
321 server
->ssocket
->flags
);
322 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
323 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
324 server
->ssocket
->state
,
325 server
->ssocket
->flags
);
326 sock_release(server
->ssocket
);
327 server
->ssocket
= NULL
;
329 server
->sequence_number
= 0;
330 server
->session_estab
= false;
331 kfree(server
->session_key
.response
);
332 server
->session_key
.response
= NULL
;
333 server
->session_key
.len
= 0;
334 server
->lstrp
= jiffies
;
335 mutex_unlock(&server
->srv_mutex
);
337 /* mark submitted MIDs for retry and issue callback */
338 INIT_LIST_HEAD(&retry_list
);
339 cFYI(1, "%s: moving mids to private list", __func__
);
340 spin_lock(&GlobalMid_Lock
);
341 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
342 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
343 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
344 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
345 list_move(&mid_entry
->qhead
, &retry_list
);
347 spin_unlock(&GlobalMid_Lock
);
349 cFYI(1, "%s: issuing mid callbacks", __func__
);
350 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
351 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
352 list_del_init(&mid_entry
->qhead
);
353 mid_entry
->callback(mid_entry
);
359 /* we should try only the port we connected to before */
360 rc
= generic_ip_connect(server
);
362 cFYI(1, "reconnect error %d", rc
);
365 atomic_inc(&tcpSesReconnectCount
);
366 spin_lock(&GlobalMid_Lock
);
367 if (server
->tcpStatus
!= CifsExiting
)
368 server
->tcpStatus
= CifsNeedNegotiate
;
369 spin_unlock(&GlobalMid_Lock
);
371 } while (server
->tcpStatus
== CifsNeedReconnect
);
378 0 not a transact2, or all data present
379 >0 transact2 with that much data missing
380 -EINVAL = invalid transact2
383 static int check2ndT2(char *buf
)
385 struct smb_hdr
*pSMB
= (struct smb_hdr
*)buf
;
386 struct smb_t2_rsp
*pSMBt
;
388 __u16 total_data_size
, data_in_this_rsp
;
390 if (pSMB
->Command
!= SMB_COM_TRANSACTION2
)
393 /* check for plausible wct, bcc and t2 data and parm sizes */
394 /* check for parm and data offset going beyond end of smb */
395 if (pSMB
->WordCount
!= 10) { /* coalesce_t2 depends on this */
396 cFYI(1, "invalid transact2 word count");
400 pSMBt
= (struct smb_t2_rsp
*)pSMB
;
402 total_data_size
= get_unaligned_le16(&pSMBt
->t2_rsp
.TotalDataCount
);
403 data_in_this_rsp
= get_unaligned_le16(&pSMBt
->t2_rsp
.DataCount
);
405 if (total_data_size
== data_in_this_rsp
)
407 else if (total_data_size
< data_in_this_rsp
) {
408 cFYI(1, "total data %d smaller than data in frame %d",
409 total_data_size
, data_in_this_rsp
);
413 remaining
= total_data_size
- data_in_this_rsp
;
415 cFYI(1, "missing %d bytes from transact2, check next response",
417 if (total_data_size
> CIFSMaxBufSize
) {
418 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
419 total_data_size
, CIFSMaxBufSize
);
425 static int coalesce_t2(char *second_buf
, struct smb_hdr
*target_hdr
)
427 struct smb_t2_rsp
*pSMBs
= (struct smb_t2_rsp
*)second_buf
;
428 struct smb_t2_rsp
*pSMBt
= (struct smb_t2_rsp
*)target_hdr
;
429 char *data_area_of_tgt
;
430 char *data_area_of_src
;
432 unsigned int byte_count
, total_in_tgt
;
433 __u16 tgt_total_cnt
, src_total_cnt
, total_in_src
;
435 src_total_cnt
= get_unaligned_le16(&pSMBs
->t2_rsp
.TotalDataCount
);
436 tgt_total_cnt
= get_unaligned_le16(&pSMBt
->t2_rsp
.TotalDataCount
);
438 if (tgt_total_cnt
!= src_total_cnt
)
439 cFYI(1, "total data count of primary and secondary t2 differ "
440 "source=%hu target=%hu", src_total_cnt
, tgt_total_cnt
);
442 total_in_tgt
= get_unaligned_le16(&pSMBt
->t2_rsp
.DataCount
);
444 remaining
= tgt_total_cnt
- total_in_tgt
;
447 cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
448 "total_in_tgt=%hu", tgt_total_cnt
, total_in_tgt
);
452 if (remaining
== 0) {
453 /* nothing to do, ignore */
454 cFYI(1, "no more data remains");
458 total_in_src
= get_unaligned_le16(&pSMBs
->t2_rsp
.DataCount
);
459 if (remaining
< total_in_src
)
460 cFYI(1, "transact2 2nd response contains too much data");
462 /* find end of first SMB data area */
463 data_area_of_tgt
= (char *)&pSMBt
->hdr
.Protocol
+
464 get_unaligned_le16(&pSMBt
->t2_rsp
.DataOffset
);
466 /* validate target area */
467 data_area_of_src
= (char *)&pSMBs
->hdr
.Protocol
+
468 get_unaligned_le16(&pSMBs
->t2_rsp
.DataOffset
);
470 data_area_of_tgt
+= total_in_tgt
;
472 total_in_tgt
+= total_in_src
;
473 /* is the result too big for the field? */
474 if (total_in_tgt
> USHRT_MAX
) {
475 cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt
);
478 put_unaligned_le16(total_in_tgt
, &pSMBt
->t2_rsp
.DataCount
);
481 byte_count
= get_bcc(target_hdr
);
482 byte_count
+= total_in_src
;
483 /* is the result too big for the field? */
484 if (byte_count
> USHRT_MAX
) {
485 cFYI(1, "coalesced BCC too large (%u)", byte_count
);
488 put_bcc(byte_count
, target_hdr
);
490 byte_count
= be32_to_cpu(target_hdr
->smb_buf_length
);
491 byte_count
+= total_in_src
;
492 /* don't allow buffer to overflow */
493 if (byte_count
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
- 4) {
494 cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count
);
497 target_hdr
->smb_buf_length
= cpu_to_be32(byte_count
);
499 /* copy second buffer into end of first buffer */
500 memcpy(data_area_of_tgt
, data_area_of_src
, total_in_src
);
502 if (remaining
!= total_in_src
) {
503 /* more responses to go */
504 cFYI(1, "waiting for more secondary responses");
509 cFYI(1, "found the last secondary response");
514 cifs_echo_request(struct work_struct
*work
)
517 struct TCP_Server_Info
*server
= container_of(work
,
518 struct TCP_Server_Info
, echo
.work
);
521 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
522 * done, which is indicated by maxBuf != 0. Also, no need to ping if
523 * we got a response recently
525 if (server
->maxBuf
== 0 ||
526 time_before(jiffies
, server
->lstrp
+ SMB_ECHO_INTERVAL
- HZ
))
529 rc
= CIFSSMBEcho(server
);
531 cFYI(1, "Unable to send echo request to server: %s",
535 queue_delayed_work(cifsiod_wq
, &server
->echo
, SMB_ECHO_INTERVAL
);
539 allocate_buffers(struct TCP_Server_Info
*server
)
541 if (!server
->bigbuf
) {
542 server
->bigbuf
= (char *)cifs_buf_get();
543 if (!server
->bigbuf
) {
544 cERROR(1, "No memory for large SMB response");
546 /* retry will check if exiting */
549 } else if (server
->large_buf
) {
550 /* we are reusing a dirty large buf, clear its start */
551 memset(server
->bigbuf
, 0, header_size());
554 if (!server
->smallbuf
) {
555 server
->smallbuf
= (char *)cifs_small_buf_get();
556 if (!server
->smallbuf
) {
557 cERROR(1, "No memory for SMB response");
559 /* retry will check if exiting */
562 /* beginning of smb buffer is cleared in our buf_get */
564 /* if existing small buf clear beginning */
565 memset(server
->smallbuf
, 0, header_size());
572 server_unresponsive(struct TCP_Server_Info
*server
)
575 * We need to wait 2 echo intervals to make sure we handle such
577 * 1s client sends a normal SMB request
578 * 2s client gets a response
579 * 30s echo workqueue job pops, and decides we got a response recently
580 * and don't need to send another
582 * 65s kernel_recvmsg times out, and we see that we haven't gotten
583 * a response in >60s.
585 if (server
->tcpStatus
== CifsGood
&&
586 time_after(jiffies
, server
->lstrp
+ 2 * SMB_ECHO_INTERVAL
)) {
587 cERROR(1, "Server %s has not responded in %d seconds. "
588 "Reconnecting...", server
->hostname
,
589 (2 * SMB_ECHO_INTERVAL
) / HZ
);
590 cifs_reconnect(server
);
591 wake_up(&server
->response_q
);
599 * kvec_array_init - clone a kvec array, and advance into it
600 * @new: pointer to memory for cloned array
601 * @iov: pointer to original array
602 * @nr_segs: number of members in original array
603 * @bytes: number of bytes to advance into the cloned array
605 * This function will copy the array provided in iov to a section of memory
606 * and advance the specified number of bytes into the new array. It returns
607 * the number of segments in the new array. "new" must be at least as big as
608 * the original iov array.
611 kvec_array_init(struct kvec
*new, struct kvec
*iov
, unsigned int nr_segs
,
616 while (bytes
|| !iov
->iov_len
) {
617 int copy
= min(bytes
, iov
->iov_len
);
621 if (iov
->iov_len
== base
) {
627 memcpy(new, iov
, sizeof(*iov
) * nr_segs
);
628 new->iov_base
+= base
;
629 new->iov_len
-= base
;
634 get_server_iovec(struct TCP_Server_Info
*server
, unsigned int nr_segs
)
636 struct kvec
*new_iov
;
638 if (server
->iov
&& nr_segs
<= server
->nr_iov
)
641 /* not big enough -- allocate a new one and release the old */
642 new_iov
= kmalloc(sizeof(*new_iov
) * nr_segs
, GFP_NOFS
);
645 server
->iov
= new_iov
;
646 server
->nr_iov
= nr_segs
;
652 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct kvec
*iov_orig
,
653 unsigned int nr_segs
, unsigned int to_read
)
658 struct msghdr smb_msg
;
661 iov
= get_server_iovec(server
, nr_segs
);
665 smb_msg
.msg_control
= NULL
;
666 smb_msg
.msg_controllen
= 0;
668 for (total_read
= 0; to_read
; total_read
+= length
, to_read
-= length
) {
671 if (server_unresponsive(server
)) {
672 total_read
= -EAGAIN
;
676 segs
= kvec_array_init(iov
, iov_orig
, nr_segs
, total_read
);
678 length
= kernel_recvmsg(server
->ssocket
, &smb_msg
,
679 iov
, segs
, to_read
, 0);
681 if (server
->tcpStatus
== CifsExiting
) {
682 total_read
= -ESHUTDOWN
;
684 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
685 cifs_reconnect(server
);
686 total_read
= -EAGAIN
;
688 } else if (length
== -ERESTARTSYS
||
692 * Minimum sleep to prevent looping, allowing socket
693 * to clear and app threads to set tcpStatus
694 * CifsNeedReconnect if server hung.
696 usleep_range(1000, 2000);
699 } else if (length
<= 0) {
700 cFYI(1, "Received no data or error: expecting %d "
701 "got %d", to_read
, length
);
702 cifs_reconnect(server
);
703 total_read
= -EAGAIN
;
711 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
712 unsigned int to_read
)
717 iov
.iov_len
= to_read
;
719 return cifs_readv_from_socket(server
, &iov
, 1, to_read
);
723 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
726 * The first byte big endian of the length field,
727 * is actually not part of the length but the type
728 * with the most common, zero, as regular data.
731 case RFC1002_SESSION_MESSAGE
:
732 /* Regular SMB response */
734 case RFC1002_SESSION_KEEP_ALIVE
:
735 cFYI(1, "RFC 1002 session keep alive");
737 case RFC1002_POSITIVE_SESSION_RESPONSE
:
738 cFYI(1, "RFC 1002 positive session response");
740 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
742 * We get this from Windows 98 instead of an error on
743 * SMB negprot response.
745 cFYI(1, "RFC 1002 negative session response");
746 /* give server a second to clean up */
749 * Always try 445 first on reconnect since we get NACK
750 * on some if we ever connected to port 139 (the NACK
751 * is since we do not begin with RFC1001 session
754 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
755 cifs_reconnect(server
);
756 wake_up(&server
->response_q
);
759 cERROR(1, "RFC 1002 unknown response type 0x%x", type
);
760 cifs_reconnect(server
);
766 static struct mid_q_entry
*
767 find_mid(struct TCP_Server_Info
*server
, char *buffer
)
769 struct smb_hdr
*buf
= (struct smb_hdr
*)buffer
;
770 struct mid_q_entry
*mid
;
772 spin_lock(&GlobalMid_Lock
);
773 list_for_each_entry(mid
, &server
->pending_mid_q
, qhead
) {
774 if (mid
->mid
== buf
->Mid
&&
775 mid
->mid_state
== MID_REQUEST_SUBMITTED
&&
776 le16_to_cpu(mid
->command
) == buf
->Command
) {
777 spin_unlock(&GlobalMid_Lock
);
781 spin_unlock(&GlobalMid_Lock
);
786 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
788 #ifdef CONFIG_CIFS_STATS2
789 mid
->when_received
= jiffies
;
791 spin_lock(&GlobalMid_Lock
);
793 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
795 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
796 list_del_init(&mid
->qhead
);
797 spin_unlock(&GlobalMid_Lock
);
801 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
802 char *buf
, int malformed
)
804 if (malformed
== 0 && check2ndT2(buf
) > 0) {
805 mid
->multiRsp
= true;
807 /* merge response - fix up 1st*/
808 malformed
= coalesce_t2(buf
, mid
->resp_buf
);
812 /* All parts received or packet is malformed. */
813 mid
->multiEnd
= true;
814 return dequeue_mid(mid
, malformed
);
816 if (!server
->large_buf
) {
817 /*FIXME: switch to already allocated largebuf?*/
818 cERROR(1, "1st trans2 resp needs bigbuf");
820 /* Have first buffer */
822 mid
->large_buf
= true;
823 server
->bigbuf
= NULL
;
828 mid
->large_buf
= server
->large_buf
;
829 /* Was previous buf put in mpx struct for multi-rsp? */
830 if (!mid
->multiRsp
) {
831 /* smb buffer will be freed by user thread */
832 if (server
->large_buf
)
833 server
->bigbuf
= NULL
;
835 server
->smallbuf
= NULL
;
837 dequeue_mid(mid
, malformed
);
840 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
844 /* take it off the list, if it's not already */
845 spin_lock(&cifs_tcp_ses_lock
);
846 list_del_init(&server
->tcp_ses_list
);
847 spin_unlock(&cifs_tcp_ses_lock
);
849 spin_lock(&GlobalMid_Lock
);
850 server
->tcpStatus
= CifsExiting
;
851 spin_unlock(&GlobalMid_Lock
);
852 wake_up_all(&server
->response_q
);
854 /* check if we have blocked requests that need to free */
855 spin_lock(&server
->req_lock
);
856 if (server
->credits
<= 0)
858 spin_unlock(&server
->req_lock
);
860 * Although there should not be any requests blocked on this queue it
861 * can not hurt to be paranoid and try to wake up requests that may
862 * haven been blocked when more than 50 at time were on the wire to the
863 * same server - they now will see the session is in exit state and get
864 * out of SendReceive.
866 wake_up_all(&server
->request_q
);
867 /* give those requests time to exit */
870 if (server
->ssocket
) {
871 sock_release(server
->ssocket
);
872 server
->ssocket
= NULL
;
875 if (!list_empty(&server
->pending_mid_q
)) {
876 struct list_head dispose_list
;
877 struct mid_q_entry
*mid_entry
;
878 struct list_head
*tmp
, *tmp2
;
880 INIT_LIST_HEAD(&dispose_list
);
881 spin_lock(&GlobalMid_Lock
);
882 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
883 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
884 cFYI(1, "Clearing mid 0x%llx", mid_entry
->mid
);
885 mid_entry
->mid_state
= MID_SHUTDOWN
;
886 list_move(&mid_entry
->qhead
, &dispose_list
);
888 spin_unlock(&GlobalMid_Lock
);
890 /* now walk dispose list and issue callbacks */
891 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
892 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
893 cFYI(1, "Callback mid 0x%llx", mid_entry
->mid
);
894 list_del_init(&mid_entry
->qhead
);
895 mid_entry
->callback(mid_entry
);
897 /* 1/8th of sec is more than enough time for them to exit */
901 if (!list_empty(&server
->pending_mid_q
)) {
903 * mpx threads have not exited yet give them at least the smb
904 * send timeout time for long ops.
906 * Due to delays on oplock break requests, we need to wait at
907 * least 45 seconds before giving up on a request getting a
908 * response and going ahead and killing cifsd.
910 cFYI(1, "Wait for exit from demultiplex thread");
913 * If threads still have not exited they are probably never
914 * coming home not much else we can do but free the memory.
918 kfree(server
->hostname
);
922 length
= atomic_dec_return(&tcpSesAllocCount
);
924 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
929 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
932 char *buf
= server
->smallbuf
;
933 unsigned int pdu_length
= get_rfc1002_length(buf
);
935 /* make sure this will fit in a large buffer */
936 if (pdu_length
> CIFSMaxBufSize
+ max_header_size() - 4) {
937 cERROR(1, "SMB response too long (%u bytes)",
939 cifs_reconnect(server
);
940 wake_up(&server
->response_q
);
944 /* switch to large buffer if too big for a small one */
945 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
946 server
->large_buf
= true;
947 memcpy(server
->bigbuf
, buf
, server
->total_read
);
948 buf
= server
->bigbuf
;
951 /* now read the rest */
952 length
= cifs_read_from_socket(server
, buf
+ header_size() - 1,
953 pdu_length
- header_size() + 1 + 4);
956 server
->total_read
+= length
;
958 dump_smb(buf
, server
->total_read
);
961 * We know that we received enough to get to the MID as we
962 * checked the pdu_length earlier. Now check to see
963 * if the rest of the header is OK. We borrow the length
964 * var for the rest of the loop to avoid a new stack var.
966 * 48 bytes is enough to display the header and a little bit
967 * into the payload for debugging purposes.
969 length
= checkSMB(buf
, server
->total_read
);
971 cifs_dump_mem("Bad SMB: ", buf
,
972 min_t(unsigned int, server
->total_read
, 48));
977 handle_mid(mid
, server
, buf
, length
);
982 cifs_demultiplex_thread(void *p
)
985 struct TCP_Server_Info
*server
= p
;
986 unsigned int pdu_length
;
988 struct task_struct
*task_to_wake
= NULL
;
989 struct mid_q_entry
*mid_entry
;
991 current
->flags
|= PF_MEMALLOC
;
992 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current
));
994 length
= atomic_inc_return(&tcpSesAllocCount
);
996 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
1000 while (server
->tcpStatus
!= CifsExiting
) {
1001 if (try_to_freeze())
1004 if (!allocate_buffers(server
))
1007 server
->large_buf
= false;
1008 buf
= server
->smallbuf
;
1009 pdu_length
= 4; /* enough to get RFC1001 header */
1011 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
1014 server
->total_read
= length
;
1017 * The right amount was read from socket - 4 bytes,
1018 * so we can now interpret the length field.
1020 pdu_length
= get_rfc1002_length(buf
);
1022 cFYI(1, "RFC1002 header 0x%x", pdu_length
);
1023 if (!is_smb_response(server
, buf
[0]))
1026 /* make sure we have enough to get to the MID */
1027 if (pdu_length
< header_size() - 1 - 4) {
1028 cERROR(1, "SMB response too short (%u bytes)",
1030 cifs_reconnect(server
);
1031 wake_up(&server
->response_q
);
1035 /* read down to the MID */
1036 length
= cifs_read_from_socket(server
, buf
+ 4,
1037 header_size() - 1 - 4);
1040 server
->total_read
+= length
;
1042 mid_entry
= find_mid(server
, buf
);
1044 if (!mid_entry
|| !mid_entry
->receive
)
1045 length
= standard_receive3(server
, mid_entry
);
1047 length
= mid_entry
->receive(server
, mid_entry
);
1052 if (server
->large_buf
)
1053 buf
= server
->bigbuf
;
1055 server
->lstrp
= jiffies
;
1056 if (mid_entry
!= NULL
) {
1057 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
1058 mid_entry
->callback(mid_entry
);
1059 } else if (!is_valid_oplock_break(buf
, server
)) {
1060 cERROR(1, "No task to wake, unknown frame received! "
1061 "NumMids %d", atomic_read(&midCount
));
1062 cifs_dump_mem("Received Data is: ", buf
, header_size());
1063 #ifdef CONFIG_CIFS_DEBUG2
1064 cifs_dump_detail(buf
);
1065 cifs_dump_mids(server
);
1066 #endif /* CIFS_DEBUG2 */
1069 } /* end while !EXITING */
1071 /* buffer usually freed in free_mid - need to free it here on exit */
1072 cifs_buf_release(server
->bigbuf
);
1073 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
1074 cifs_small_buf_release(server
->smallbuf
);
1076 task_to_wake
= xchg(&server
->tsk
, NULL
);
1077 clean_demultiplex_info(server
);
1079 /* if server->tsk was NULL then wait for a signal before exiting */
1080 if (!task_to_wake
) {
1081 set_current_state(TASK_INTERRUPTIBLE
);
1082 while (!signal_pending(current
)) {
1084 set_current_state(TASK_INTERRUPTIBLE
);
1086 set_current_state(TASK_RUNNING
);
1089 module_put_and_exit(0);
1092 /* extract the host portion of the UNC string */
1094 extract_hostname(const char *unc
)
1100 /* skip double chars at beginning of string */
1101 /* BB: check validity of these bytes? */
1104 /* delimiter between hostname and sharename is always '\\' now */
1105 delim
= strchr(src
, '\\');
1107 return ERR_PTR(-EINVAL
);
1110 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
1112 return ERR_PTR(-ENOMEM
);
1114 memcpy(dst
, src
, len
);
1120 static int get_option_ul(substring_t args
[], unsigned long *option
)
1125 string
= match_strdup(args
);
1128 rc
= kstrtoul(string
, 0, option
);
1135 static int cifs_parse_security_flavors(char *value
,
1136 struct smb_vol
*vol
)
1139 substring_t args
[MAX_OPT_ARGS
];
1141 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1143 vol
->secFlg
|= CIFSSEC_MAY_KRB5
;
1146 vol
->secFlg
|= CIFSSEC_MAY_KRB5
| CIFSSEC_MUST_SIGN
;
1149 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1150 cERROR(1, "Krb5 cifs privacy not supported");
1152 case Opt_sec_ntlmssp
:
1153 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
;
1155 case Opt_sec_ntlmsspi
:
1156 vol
->secFlg
|= CIFSSEC_MAY_NTLMSSP
| CIFSSEC_MUST_SIGN
;
1159 /* ntlm is default so can be turned off too */
1160 vol
->secFlg
|= CIFSSEC_MAY_NTLM
;
1163 vol
->secFlg
|= CIFSSEC_MAY_NTLM
| CIFSSEC_MUST_SIGN
;
1165 case Opt_sec_nontlm
:
1166 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
1168 case Opt_sec_ntlmv2i
:
1169 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
| CIFSSEC_MUST_SIGN
;
1171 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1172 case Opt_sec_lanman
:
1173 vol
->secFlg
|= CIFSSEC_MAY_LANMAN
;
1180 cERROR(1, "bad security option: %s", value
);
1188 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1189 struct smb_vol
*vol
)
1192 char *mountdata_copy
= NULL
, *options
;
1193 unsigned int temp_len
, i
, j
;
1195 short int override_uid
= -1;
1196 short int override_gid
= -1;
1197 bool uid_specified
= false;
1198 bool gid_specified
= false;
1199 bool sloppy
= false;
1200 char *invalid
= NULL
;
1201 char *nodename
= utsname()->nodename
;
1202 char *string
= NULL
;
1203 char *tmp_end
, *value
;
1208 delim
= separator
[0];
1211 * does not have to be perfect mapping since field is
1212 * informational, only used for servers that do not support
1213 * port 445 and it can be overridden at mount time
1215 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1216 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1217 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1219 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1220 /* null target name indicates to use *SMBSERVR default called name
1221 if we end up sending RFC1001 session initialize */
1222 vol
->target_rfc1001_name
[0] = 0;
1223 vol
->cred_uid
= current_uid();
1224 vol
->linux_uid
= current_uid();
1225 vol
->linux_gid
= current_gid();
1227 /* default to only allowing write access to owner of the mount */
1228 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1230 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1231 /* default is always to request posix paths. */
1232 vol
->posix_paths
= 1;
1233 /* default to using server inode numbers where available */
1234 vol
->server_ino
= 1;
1236 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1239 goto cifs_parse_mount_err
;
1241 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1242 if (!mountdata_copy
)
1243 goto cifs_parse_mount_err
;
1245 options
= mountdata_copy
;
1246 end
= options
+ strlen(options
);
1248 if (strncmp(options
, "sep=", 4) == 0) {
1249 if (options
[4] != 0) {
1250 separator
[0] = options
[4];
1253 cFYI(1, "Null separator not allowed");
1256 vol
->backupuid_specified
= false; /* no backup intent for a user */
1257 vol
->backupgid_specified
= false; /* no backup intent for a group */
1259 while ((data
= strsep(&options
, separator
)) != NULL
) {
1260 substring_t args
[MAX_OPT_ARGS
];
1261 unsigned long option
;
1267 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1271 /* Ingnore the following */
1275 /* Boolean values */
1276 case Opt_user_xattr
:
1279 case Opt_nouser_xattr
:
1285 case Opt_noforceuid
:
1288 case Opt_noblocksend
:
1289 vol
->noblocksnd
= 1;
1291 case Opt_noautotune
:
1292 vol
->noautotune
= 1;
1309 case Opt_nomapchars
:
1321 case Opt_posixpaths
:
1322 vol
->posix_paths
= 1;
1324 case Opt_noposixpaths
:
1325 vol
->posix_paths
= 0;
1328 vol
->no_linux_ext
= 1;
1339 * turn off mandatory locking in mode
1340 * if remote locking is turned off since the
1341 * local vfs will do advisory
1343 if (vol
->file_mode
==
1344 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1345 vol
->file_mode
= S_IALLUGO
;
1347 case Opt_forcemandatorylock
:
1357 vol
->dynperm
= true;
1360 vol
->dynperm
= false;
1374 case Opt_nostrictsync
:
1375 vol
->nostrictsync
= 1;
1377 case Opt_strictsync
:
1378 vol
->nostrictsync
= 0;
1381 vol
->server_ino
= 1;
1383 case Opt_noserverino
:
1384 vol
->server_ino
= 0;
1386 case Opt_rwpidforward
:
1387 vol
->rwpidforward
= 1;
1396 vol
->no_psx_acl
= 0;
1399 vol
->no_psx_acl
= 1;
1401 case Opt_locallease
:
1402 vol
->local_lease
= 1;
1405 vol
->secFlg
|= CIFSSEC_MUST_SIGN
;
1408 /* we do not do the following in secFlags because seal
1409 * is a per tree connection (mount) not a per socket
1410 * or per-smb connection option in the protocol
1411 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1418 case Opt_strictcache
:
1422 printk(KERN_WARNING
"CIFS: Mount option noac not "
1423 "supported. Instead set "
1424 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1427 #ifndef CONFIG_CIFS_FSCACHE
1428 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1429 "kernel config option set");
1430 goto cifs_parse_mount_err
;
1434 case Opt_mfsymlinks
:
1435 vol
->mfsymlinks
= true;
1438 vol
->multiuser
= true;
1444 /* Numeric Values */
1446 if (get_option_ul(args
, &option
)) {
1447 cERROR(1, "%s: Invalid backupuid value",
1449 goto cifs_parse_mount_err
;
1451 vol
->backupuid
= option
;
1452 vol
->backupuid_specified
= true;
1455 if (get_option_ul(args
, &option
)) {
1456 cERROR(1, "%s: Invalid backupgid value",
1458 goto cifs_parse_mount_err
;
1460 vol
->backupgid
= option
;
1461 vol
->backupgid_specified
= true;
1464 if (get_option_ul(args
, &option
)) {
1465 cERROR(1, "%s: Invalid uid value",
1467 goto cifs_parse_mount_err
;
1469 vol
->linux_uid
= option
;
1470 uid_specified
= true;
1473 if (get_option_ul(args
, &option
)) {
1474 cERROR(1, "%s: Invalid cruid value",
1476 goto cifs_parse_mount_err
;
1478 vol
->cred_uid
= option
;
1481 if (get_option_ul(args
, &option
)) {
1482 cERROR(1, "%s: Invalid gid value",
1484 goto cifs_parse_mount_err
;
1486 vol
->linux_gid
= option
;
1487 gid_specified
= true;
1490 if (get_option_ul(args
, &option
)) {
1491 cERROR(1, "%s: Invalid file_mode value",
1493 goto cifs_parse_mount_err
;
1495 vol
->file_mode
= option
;
1498 if (get_option_ul(args
, &option
)) {
1499 cERROR(1, "%s: Invalid dir_mode value",
1501 goto cifs_parse_mount_err
;
1503 vol
->dir_mode
= option
;
1506 if (get_option_ul(args
, &option
)) {
1507 cERROR(1, "%s: Invalid port value",
1509 goto cifs_parse_mount_err
;
1514 if (get_option_ul(args
, &option
)) {
1515 cERROR(1, "%s: Invalid rsize value",
1517 goto cifs_parse_mount_err
;
1519 vol
->rsize
= option
;
1522 if (get_option_ul(args
, &option
)) {
1523 cERROR(1, "%s: Invalid wsize value",
1525 goto cifs_parse_mount_err
;
1527 vol
->wsize
= option
;
1530 if (get_option_ul(args
, &option
)) {
1531 cERROR(1, "%s: Invalid actimeo value",
1533 goto cifs_parse_mount_err
;
1535 vol
->actimeo
= HZ
* option
;
1536 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1537 cERROR(1, "CIFS: attribute cache"
1538 "timeout too large");
1539 goto cifs_parse_mount_err
;
1543 /* String Arguments */
1545 case Opt_blank_user
:
1546 /* null user, ie. anonymous authentication */
1548 vol
->username
= NULL
;
1551 string
= match_strdup(args
);
1555 if (strnlen(string
, MAX_USERNAME_SIZE
) >
1556 MAX_USERNAME_SIZE
) {
1557 printk(KERN_WARNING
"CIFS: username too long\n");
1558 goto cifs_parse_mount_err
;
1560 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1561 if (!vol
->username
) {
1562 printk(KERN_WARNING
"CIFS: no memory "
1564 goto cifs_parse_mount_err
;
1567 case Opt_blank_pass
:
1568 vol
->password
= NULL
;
1571 /* passwords have to be handled differently
1572 * to allow the character used for deliminator
1573 * to be passed within them
1576 /* Obtain the value string */
1577 value
= strchr(data
, '=');
1580 /* Set tmp_end to end of the string */
1581 tmp_end
= (char *) value
+ strlen(value
);
1583 /* Check if following character is the deliminator
1584 * If yes, we have encountered a double deliminator
1585 * reset the NULL character to the deliminator
1587 if (tmp_end
< end
&& tmp_end
[1] == delim
)
1590 /* Keep iterating until we get to a single deliminator
1593 while ((tmp_end
= strchr(tmp_end
, delim
)) != NULL
&&
1594 (tmp_end
[1] == delim
)) {
1595 tmp_end
= (char *) &tmp_end
[2];
1598 /* Reset var options to point to next element */
1601 options
= (char *) &tmp_end
[1];
1603 /* Reached the end of the mount option string */
1606 /* Now build new password string */
1607 temp_len
= strlen(value
);
1608 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1609 if (vol
->password
== NULL
) {
1610 printk(KERN_WARNING
"CIFS: no memory "
1612 goto cifs_parse_mount_err
;
1615 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1616 vol
->password
[j
] = value
[i
];
1617 if ((value
[i
] == delim
) &&
1618 value
[i
+1] == delim
)
1619 /* skip the second deliminator */
1622 vol
->password
[j
] = '\0';
1628 string
= match_strdup(args
);
1632 if (strnlen(string
, INET6_ADDRSTRLEN
) >
1634 printk(KERN_WARNING
"CIFS: ip address "
1636 goto cifs_parse_mount_err
;
1638 vol
->UNCip
= kstrdup(string
, GFP_KERNEL
);
1640 printk(KERN_WARNING
"CIFS: no memory "
1642 goto cifs_parse_mount_err
;
1646 string
= match_strdup(args
);
1650 temp_len
= strnlen(string
, 300);
1651 if (temp_len
== 300) {
1652 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1653 goto cifs_parse_mount_err
;
1656 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1657 if (vol
->UNC
== NULL
) {
1658 printk(KERN_WARNING
"CIFS: no memory for UNC\n");
1659 goto cifs_parse_mount_err
;
1661 strcpy(vol
->UNC
, string
);
1663 if (strncmp(string
, "//", 2) == 0) {
1666 } else if (strncmp(string
, "\\\\", 2) != 0) {
1667 printk(KERN_WARNING
"CIFS: UNC Path does not "
1668 "begin with // or \\\\\n");
1669 goto cifs_parse_mount_err
;
1674 string
= match_strdup(args
);
1678 if (strnlen(string
, 256) == 256) {
1679 printk(KERN_WARNING
"CIFS: domain name too"
1681 goto cifs_parse_mount_err
;
1684 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1685 if (!vol
->domainname
) {
1686 printk(KERN_WARNING
"CIFS: no memory "
1687 "for domainname\n");
1688 goto cifs_parse_mount_err
;
1690 cFYI(1, "Domain name set");
1693 string
= match_strdup(args
);
1697 if (!cifs_convert_address(
1698 (struct sockaddr
*)&vol
->srcaddr
,
1699 string
, strlen(string
))) {
1700 printk(KERN_WARNING
"CIFS: Could not parse"
1701 " srcaddr: %s\n", string
);
1702 goto cifs_parse_mount_err
;
1705 case Opt_prefixpath
:
1706 string
= match_strdup(args
);
1710 temp_len
= strnlen(string
, 1024);
1711 if (string
[0] != '/')
1712 temp_len
++; /* missing leading slash */
1713 if (temp_len
> 1024) {
1714 printk(KERN_WARNING
"CIFS: prefix too long\n");
1715 goto cifs_parse_mount_err
;
1718 vol
->prepath
= kmalloc(temp_len
+1, GFP_KERNEL
);
1719 if (vol
->prepath
== NULL
) {
1720 printk(KERN_WARNING
"CIFS: no memory "
1721 "for path prefix\n");
1722 goto cifs_parse_mount_err
;
1725 if (string
[0] != '/') {
1726 vol
->prepath
[0] = '/';
1727 strcpy(vol
->prepath
+1, string
);
1729 strcpy(vol
->prepath
, string
);
1733 string
= match_strdup(args
);
1737 if (strnlen(string
, 1024) >= 65) {
1738 printk(KERN_WARNING
"CIFS: iocharset name "
1740 goto cifs_parse_mount_err
;
1743 if (strnicmp(string
, "default", 7) != 0) {
1744 vol
->iocharset
= kstrdup(string
,
1746 if (!vol
->iocharset
) {
1747 printk(KERN_WARNING
"CIFS: no memory"
1749 goto cifs_parse_mount_err
;
1752 /* if iocharset not set then load_nls_default
1755 cFYI(1, "iocharset set to %s", string
);
1758 string
= match_strdup(args
);
1762 if (strnicmp(string
, "TCP_NODELAY", 11) == 0)
1763 vol
->sockopt_tcp_nodelay
= 1;
1765 case Opt_netbiosname
:
1766 string
= match_strdup(args
);
1770 memset(vol
->source_rfc1001_name
, 0x20,
1773 * FIXME: are there cases in which a comma can
1774 * be valid in workstation netbios name (and
1775 * need special handling)?
1777 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1778 /* don't ucase netbiosname for user */
1781 vol
->source_rfc1001_name
[i
] = string
[i
];
1783 /* The string has 16th byte zero still from
1784 * set at top of the function
1786 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1787 printk(KERN_WARNING
"CIFS: netbiosname"
1788 " longer than 15 truncated.\n");
1792 /* servernetbiosname specified override *SMBSERVER */
1793 string
= match_strdup(args
);
1797 /* last byte, type, is 0x20 for servr type */
1798 memset(vol
->target_rfc1001_name
, 0x20,
1799 RFC1001_NAME_LEN_WITH_NULL
);
1801 /* BB are there cases in which a comma can be
1802 valid in this workstation netbios name
1803 (and need special handling)? */
1805 /* user or mount helper must uppercase the
1807 for (i
= 0; i
< 15; i
++) {
1810 vol
->target_rfc1001_name
[i
] = string
[i
];
1812 /* The string has 16th byte zero still from
1813 set at top of the function */
1814 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1815 printk(KERN_WARNING
"CIFS: server net"
1816 "biosname longer than 15 truncated.\n");
1819 string
= match_strdup(args
);
1823 if (strnicmp(string
, "cifs", 4) == 0 ||
1824 strnicmp(string
, "1", 1) == 0) {
1825 /* This is the default */
1828 /* For all other value, error */
1829 printk(KERN_WARNING
"CIFS: Invalid version"
1831 goto cifs_parse_mount_err
;
1833 string
= match_strdup(args
);
1837 if (cifs_parse_security_flavors(string
, vol
) != 0)
1838 goto cifs_parse_mount_err
;
1842 * An option we don't recognize. Save it off for later
1843 * if we haven't already found one
1849 /* Free up any allocated string */
1854 if (!sloppy
&& invalid
) {
1855 printk(KERN_ERR
"CIFS: Unknown mount option \"%s\"\n", invalid
);
1856 goto cifs_parse_mount_err
;
1860 /* Muliuser mounts require CONFIG_KEYS support */
1861 if (vol
->multiuser
) {
1862 cERROR(1, "Multiuser mounts require kernels with "
1863 "CONFIG_KEYS enabled.");
1864 goto cifs_parse_mount_err
;
1868 if (vol
->UNCip
== NULL
)
1869 vol
->UNCip
= &vol
->UNC
[2];
1872 vol
->override_uid
= override_uid
;
1873 else if (override_uid
== 1)
1874 printk(KERN_NOTICE
"CIFS: ignoring forceuid mount option "
1875 "specified with no uid= option.\n");
1878 vol
->override_gid
= override_gid
;
1879 else if (override_gid
== 1)
1880 printk(KERN_NOTICE
"CIFS: ignoring forcegid mount option "
1881 "specified with no gid= option.\n");
1883 kfree(mountdata_copy
);
1887 printk(KERN_WARNING
"Could not allocate temporary buffer\n");
1888 cifs_parse_mount_err
:
1890 kfree(mountdata_copy
);
1894 /** Returns true if srcaddr isn't specified and rhs isn't
1895 * specified, or if srcaddr is specified and
1896 * matches the IP address of the rhs argument.
1899 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1901 switch (srcaddr
->sa_family
) {
1903 return (rhs
->sa_family
== AF_UNSPEC
);
1905 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1906 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1907 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1910 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1911 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)&rhs
;
1912 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1916 return false; /* don't expect to be here */
1921 * If no port is specified in addr structure, we try to match with 445 port
1922 * and if it fails - with 139 ports. It should be called only if address
1923 * families of server and addr are equal.
1926 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1928 __be16 port
, *sport
;
1930 switch (addr
->sa_family
) {
1932 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1933 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1936 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1937 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1945 port
= htons(CIFS_PORT
);
1949 port
= htons(RFC1001_PORT
);
1952 return port
== *sport
;
1956 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1957 struct sockaddr
*srcaddr
)
1959 switch (addr
->sa_family
) {
1961 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
1962 struct sockaddr_in
*srv_addr4
=
1963 (struct sockaddr_in
*)&server
->dstaddr
;
1965 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
1970 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
1971 struct sockaddr_in6
*srv_addr6
=
1972 (struct sockaddr_in6
*)&server
->dstaddr
;
1974 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
1975 &srv_addr6
->sin6_addr
))
1977 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
1983 return false; /* don't expect to be here */
1986 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
1993 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
1995 unsigned int secFlags
;
1997 if (vol
->secFlg
& (~(CIFSSEC_MUST_SIGN
| CIFSSEC_MUST_SEAL
)))
1998 secFlags
= vol
->secFlg
;
2000 secFlags
= global_secflags
| vol
->secFlg
;
2002 switch (server
->secType
) {
2004 if (!(secFlags
& (CIFSSEC_MAY_LANMAN
|CIFSSEC_MAY_PLNTXT
)))
2008 if (!(secFlags
& CIFSSEC_MAY_NTLMV2
))
2012 if (!(secFlags
& CIFSSEC_MAY_NTLM
))
2016 if (!(secFlags
& CIFSSEC_MAY_KRB5
))
2020 if (!(secFlags
& CIFSSEC_MAY_NTLMSSP
))
2024 /* shouldn't happen */
2028 /* now check if signing mode is acceptable */
2029 if ((secFlags
& CIFSSEC_MAY_SIGN
) == 0 &&
2030 (server
->sec_mode
& SECMODE_SIGN_REQUIRED
))
2032 else if (((secFlags
& CIFSSEC_MUST_SIGN
) == CIFSSEC_MUST_SIGN
) &&
2034 (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
)) == 0)
2040 static int match_server(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
2041 struct smb_vol
*vol
)
2043 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2046 if (!match_address(server
, addr
,
2047 (struct sockaddr
*)&vol
->srcaddr
))
2050 if (!match_port(server
, addr
))
2053 if (!match_security(server
, vol
))
2059 static struct TCP_Server_Info
*
2060 cifs_find_tcp_session(struct sockaddr
*addr
, struct smb_vol
*vol
)
2062 struct TCP_Server_Info
*server
;
2064 spin_lock(&cifs_tcp_ses_lock
);
2065 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2066 if (!match_server(server
, addr
, vol
))
2069 ++server
->srv_count
;
2070 spin_unlock(&cifs_tcp_ses_lock
);
2071 cFYI(1, "Existing tcp session with server found");
2074 spin_unlock(&cifs_tcp_ses_lock
);
2079 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
2081 struct task_struct
*task
;
2083 spin_lock(&cifs_tcp_ses_lock
);
2084 if (--server
->srv_count
> 0) {
2085 spin_unlock(&cifs_tcp_ses_lock
);
2089 put_net(cifs_net_ns(server
));
2091 list_del_init(&server
->tcp_ses_list
);
2092 spin_unlock(&cifs_tcp_ses_lock
);
2094 cancel_delayed_work_sync(&server
->echo
);
2096 spin_lock(&GlobalMid_Lock
);
2097 server
->tcpStatus
= CifsExiting
;
2098 spin_unlock(&GlobalMid_Lock
);
2100 cifs_crypto_shash_release(server
);
2101 cifs_fscache_release_client_cookie(server
);
2103 kfree(server
->session_key
.response
);
2104 server
->session_key
.response
= NULL
;
2105 server
->session_key
.len
= 0;
2107 task
= xchg(&server
->tsk
, NULL
);
2109 force_sig(SIGKILL
, task
);
2112 static struct TCP_Server_Info
*
2113 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2115 struct TCP_Server_Info
*tcp_ses
= NULL
;
2116 struct sockaddr_storage addr
;
2117 struct sockaddr_in
*sin_server
= (struct sockaddr_in
*) &addr
;
2118 struct sockaddr_in6
*sin_server6
= (struct sockaddr_in6
*) &addr
;
2121 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
2123 cFYI(1, "UNC: %s ip: %s", volume_info
->UNC
, volume_info
->UNCip
);
2125 if (volume_info
->UNCip
&& volume_info
->UNC
) {
2126 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
2128 strlen(volume_info
->UNCip
),
2131 /* we failed translating address */
2135 } else if (volume_info
->UNCip
) {
2136 /* BB using ip addr as tcp_ses name to connect to the
2138 cERROR(1, "Connecting to DFS root not implemented yet");
2141 } else /* which tcp_sess DFS root would we conect to */ {
2142 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2143 "unc=//192.168.1.100/public) specified");
2148 /* see if we already have a matching tcp_ses */
2149 tcp_ses
= cifs_find_tcp_session((struct sockaddr
*)&addr
, volume_info
);
2153 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2159 rc
= cifs_crypto_shash_allocate(tcp_ses
);
2161 cERROR(1, "could not setup hash structures rc %d", rc
);
2165 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2166 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2167 if (IS_ERR(tcp_ses
->hostname
)) {
2168 rc
= PTR_ERR(tcp_ses
->hostname
);
2169 goto out_err_crypto_release
;
2172 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2173 tcp_ses
->noautotune
= volume_info
->noautotune
;
2174 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2175 tcp_ses
->in_flight
= 0;
2176 tcp_ses
->credits
= 1;
2177 init_waitqueue_head(&tcp_ses
->response_q
);
2178 init_waitqueue_head(&tcp_ses
->request_q
);
2179 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2180 mutex_init(&tcp_ses
->srv_mutex
);
2181 memcpy(tcp_ses
->workstation_RFC1001_name
,
2182 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2183 memcpy(tcp_ses
->server_RFC1001_name
,
2184 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2185 tcp_ses
->session_estab
= false;
2186 tcp_ses
->sequence_number
= 0;
2187 tcp_ses
->lstrp
= jiffies
;
2188 spin_lock_init(&tcp_ses
->req_lock
);
2189 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2190 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2191 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2194 * at this point we are the only ones with the pointer
2195 * to the struct since the kernel thread not created yet
2196 * no need to spinlock this init of tcpStatus or srv_count
2198 tcp_ses
->tcpStatus
= CifsNew
;
2199 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2200 sizeof(tcp_ses
->srcaddr
));
2201 ++tcp_ses
->srv_count
;
2203 if (addr
.ss_family
== AF_INET6
) {
2204 cFYI(1, "attempting ipv6 connect");
2205 /* BB should we allow ipv6 on port 139? */
2206 /* other OS never observed in Wild doing 139 with v6 */
2207 memcpy(&tcp_ses
->dstaddr
, sin_server6
,
2208 sizeof(struct sockaddr_in6
));
2210 memcpy(&tcp_ses
->dstaddr
, sin_server
,
2211 sizeof(struct sockaddr_in
));
2213 rc
= ip_connect(tcp_ses
);
2215 cERROR(1, "Error connecting to socket. Aborting operation");
2216 goto out_err_crypto_release
;
2220 * since we're in a cifs function already, we know that
2221 * this will succeed. No need for try_module_get().
2223 __module_get(THIS_MODULE
);
2224 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2226 if (IS_ERR(tcp_ses
->tsk
)) {
2227 rc
= PTR_ERR(tcp_ses
->tsk
);
2228 cERROR(1, "error %d create cifsd thread", rc
);
2229 module_put(THIS_MODULE
);
2230 goto out_err_crypto_release
;
2232 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2234 /* thread spawned, put it on the list */
2235 spin_lock(&cifs_tcp_ses_lock
);
2236 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2237 spin_unlock(&cifs_tcp_ses_lock
);
2239 cifs_fscache_get_client_cookie(tcp_ses
);
2241 /* queue echo request delayed work */
2242 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, SMB_ECHO_INTERVAL
);
2246 out_err_crypto_release
:
2247 cifs_crypto_shash_release(tcp_ses
);
2249 put_net(cifs_net_ns(tcp_ses
));
2253 if (!IS_ERR(tcp_ses
->hostname
))
2254 kfree(tcp_ses
->hostname
);
2255 if (tcp_ses
->ssocket
)
2256 sock_release(tcp_ses
->ssocket
);
2262 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2264 switch (ses
->server
->secType
) {
2266 if (vol
->cred_uid
!= ses
->cred_uid
)
2270 /* NULL username means anonymous session */
2271 if (ses
->user_name
== NULL
) {
2277 /* anything else takes username/password */
2278 if (strncmp(ses
->user_name
,
2279 vol
->username
? vol
->username
: "",
2282 if (strlen(vol
->username
) != 0 &&
2283 ses
->password
!= NULL
&&
2284 strncmp(ses
->password
,
2285 vol
->password
? vol
->password
: "",
2292 static struct cifs_ses
*
2293 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2295 struct cifs_ses
*ses
;
2297 spin_lock(&cifs_tcp_ses_lock
);
2298 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2299 if (!match_session(ses
, vol
))
2302 spin_unlock(&cifs_tcp_ses_lock
);
2305 spin_unlock(&cifs_tcp_ses_lock
);
2310 cifs_put_smb_ses(struct cifs_ses
*ses
)
2313 struct TCP_Server_Info
*server
= ses
->server
;
2315 cFYI(1, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2316 spin_lock(&cifs_tcp_ses_lock
);
2317 if (--ses
->ses_count
> 0) {
2318 spin_unlock(&cifs_tcp_ses_lock
);
2322 list_del_init(&ses
->smb_ses_list
);
2323 spin_unlock(&cifs_tcp_ses_lock
);
2325 if (ses
->status
== CifsGood
) {
2327 CIFSSMBLogoff(xid
, ses
);
2331 cifs_put_tcp_session(server
);
2336 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2337 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2339 /* Populate username and pw fields from keyring if possible */
2341 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2344 char *desc
, *delim
, *payload
;
2347 struct TCP_Server_Info
*server
= ses
->server
;
2348 struct sockaddr_in
*sa
;
2349 struct sockaddr_in6
*sa6
;
2350 struct user_key_payload
*upayload
;
2352 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2356 /* try to find an address key first */
2357 switch (server
->dstaddr
.ss_family
) {
2359 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2360 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2363 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2364 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2367 cFYI(1, "Bad ss_family (%hu)", server
->dstaddr
.ss_family
);
2372 cFYI(1, "%s: desc=%s", __func__
, desc
);
2373 key
= request_key(&key_type_logon
, desc
, "");
2375 if (!ses
->domainName
) {
2376 cFYI(1, "domainName is NULL");
2381 /* didn't work, try to find a domain key */
2382 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2383 cFYI(1, "%s: desc=%s", __func__
, desc
);
2384 key
= request_key(&key_type_logon
, desc
, "");
2391 down_read(&key
->sem
);
2392 upayload
= key
->payload
.data
;
2393 if (IS_ERR_OR_NULL(upayload
)) {
2394 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2398 /* find first : in payload */
2399 payload
= (char *)upayload
->data
;
2400 delim
= strnchr(payload
, upayload
->datalen
, ':');
2401 cFYI(1, "payload=%s", payload
);
2403 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2409 len
= delim
- payload
;
2410 if (len
> MAX_USERNAME_SIZE
|| len
<= 0) {
2411 cFYI(1, "Bad value from username search (len=%zd)", len
);
2416 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2417 if (!vol
->username
) {
2418 cFYI(1, "Unable to allocate %zd bytes for username", len
);
2422 cFYI(1, "%s: username=%s", __func__
, vol
->username
);
2424 len
= key
->datalen
- (len
+ 1);
2425 if (len
> MAX_PASSWORD_SIZE
|| len
<= 0) {
2426 cFYI(1, "Bad len for password search (len=%zd)", len
);
2428 kfree(vol
->username
);
2429 vol
->username
= NULL
;
2434 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2435 if (!vol
->password
) {
2436 cFYI(1, "Unable to allocate %zd bytes for password", len
);
2438 kfree(vol
->username
);
2439 vol
->username
= NULL
;
2448 cFYI(1, "%s: returning %d", __func__
, rc
);
2451 #else /* ! CONFIG_KEYS */
2453 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2454 struct cifs_ses
*ses
__attribute__((unused
)))
2458 #endif /* CONFIG_KEYS */
2460 static bool warned_on_ntlm
; /* globals init to false automatically */
2462 static struct cifs_ses
*
2463 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2465 int rc
= -ENOMEM
, xid
;
2466 struct cifs_ses
*ses
;
2467 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2468 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2472 ses
= cifs_find_smb_ses(server
, volume_info
);
2474 cFYI(1, "Existing smb sess found (status=%d)", ses
->status
);
2476 mutex_lock(&ses
->session_mutex
);
2477 rc
= cifs_negotiate_protocol(xid
, ses
);
2479 mutex_unlock(&ses
->session_mutex
);
2480 /* problem -- put our ses reference */
2481 cifs_put_smb_ses(ses
);
2485 if (ses
->need_reconnect
) {
2486 cFYI(1, "Session needs reconnect");
2487 rc
= cifs_setup_session(xid
, ses
,
2488 volume_info
->local_nls
);
2490 mutex_unlock(&ses
->session_mutex
);
2491 /* problem -- put our reference */
2492 cifs_put_smb_ses(ses
);
2497 mutex_unlock(&ses
->session_mutex
);
2499 /* existing SMB ses has a server reference already */
2500 cifs_put_tcp_session(server
);
2505 cFYI(1, "Existing smb sess not found");
2506 ses
= sesInfoAlloc();
2510 /* new SMB session uses our server ref */
2511 ses
->server
= server
;
2512 if (server
->dstaddr
.ss_family
== AF_INET6
)
2513 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2515 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2517 if (volume_info
->username
) {
2518 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2519 if (!ses
->user_name
)
2523 /* volume_info->password freed at unmount */
2524 if (volume_info
->password
) {
2525 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2529 if (volume_info
->domainname
) {
2530 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2531 if (!ses
->domainName
)
2534 ses
->cred_uid
= volume_info
->cred_uid
;
2535 ses
->linux_uid
= volume_info
->linux_uid
;
2537 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2538 supported for many years, time to update default security mechanism */
2539 if ((volume_info
->secFlg
== 0) && warned_on_ntlm
== false) {
2540 warned_on_ntlm
= true;
2541 cERROR(1, "default security mechanism requested. The default "
2542 "security mechanism will be upgraded from ntlm to "
2543 "ntlmv2 in kernel release 3.3");
2545 ses
->overrideSecFlg
= volume_info
->secFlg
;
2547 mutex_lock(&ses
->session_mutex
);
2548 rc
= cifs_negotiate_protocol(xid
, ses
);
2550 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2551 mutex_unlock(&ses
->session_mutex
);
2555 /* success, put it on the list */
2556 spin_lock(&cifs_tcp_ses_lock
);
2557 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2558 spin_unlock(&cifs_tcp_ses_lock
);
2569 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2571 if (tcon
->tidStatus
== CifsExiting
)
2573 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2578 static struct cifs_tcon
*
2579 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2581 struct list_head
*tmp
;
2582 struct cifs_tcon
*tcon
;
2584 spin_lock(&cifs_tcp_ses_lock
);
2585 list_for_each(tmp
, &ses
->tcon_list
) {
2586 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2587 if (!match_tcon(tcon
, unc
))
2590 spin_unlock(&cifs_tcp_ses_lock
);
2593 spin_unlock(&cifs_tcp_ses_lock
);
2598 cifs_put_tcon(struct cifs_tcon
*tcon
)
2601 struct cifs_ses
*ses
= tcon
->ses
;
2603 cFYI(1, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2604 spin_lock(&cifs_tcp_ses_lock
);
2605 if (--tcon
->tc_count
> 0) {
2606 spin_unlock(&cifs_tcp_ses_lock
);
2610 list_del_init(&tcon
->tcon_list
);
2611 spin_unlock(&cifs_tcp_ses_lock
);
2614 CIFSSMBTDis(xid
, tcon
);
2617 cifs_fscache_release_super_cookie(tcon
);
2619 cifs_put_smb_ses(ses
);
2622 static struct cifs_tcon
*
2623 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2626 struct cifs_tcon
*tcon
;
2628 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2630 cFYI(1, "Found match on UNC path");
2631 /* existing tcon already has a reference */
2632 cifs_put_smb_ses(ses
);
2633 if (tcon
->seal
!= volume_info
->seal
)
2634 cERROR(1, "transport encryption setting "
2635 "conflicts with existing tid");
2639 tcon
= tconInfoAlloc();
2646 if (volume_info
->password
) {
2647 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2648 if (!tcon
->password
) {
2654 if (strchr(volume_info
->UNC
+ 3, '\\') == NULL
2655 && strchr(volume_info
->UNC
+ 3, '/') == NULL
) {
2656 cERROR(1, "Missing share name");
2661 /* BB Do we need to wrap session_mutex around
2662 * this TCon call and Unix SetFS as
2663 * we do on SessSetup and reconnect? */
2665 rc
= CIFSTCon(xid
, ses
, volume_info
->UNC
, tcon
, volume_info
->local_nls
);
2667 cFYI(1, "CIFS Tcon rc = %d", rc
);
2671 if (volume_info
->nodfs
) {
2672 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2673 cFYI(1, "DFS disabled (%d)", tcon
->Flags
);
2675 tcon
->seal
= volume_info
->seal
;
2676 /* we can have only one retry value for a connection
2677 to a share so for resources mounted more than once
2678 to the same server share the last value passed in
2679 for the retry flag is used */
2680 tcon
->retry
= volume_info
->retry
;
2681 tcon
->nocase
= volume_info
->nocase
;
2682 tcon
->local_lease
= volume_info
->local_lease
;
2684 spin_lock(&cifs_tcp_ses_lock
);
2685 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2686 spin_unlock(&cifs_tcp_ses_lock
);
2688 cifs_fscache_get_super_cookie(tcon
);
2698 cifs_put_tlink(struct tcon_link
*tlink
)
2700 if (!tlink
|| IS_ERR(tlink
))
2703 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2704 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2705 tlink
->tl_time
= jiffies
;
2709 if (!IS_ERR(tlink_tcon(tlink
)))
2710 cifs_put_tcon(tlink_tcon(tlink
));
2715 static inline struct tcon_link
*
2716 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2718 return cifs_sb
->master_tlink
;
2722 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2724 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2725 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2727 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2730 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2731 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2735 * We want to share sb only if we don't specify an r/wsize or
2736 * specified r/wsize is greater than or equal to existing one.
2738 if (new->wsize
&& new->wsize
< old
->wsize
)
2741 if (new->rsize
&& new->rsize
< old
->rsize
)
2744 if (old
->mnt_uid
!= new->mnt_uid
|| old
->mnt_gid
!= new->mnt_gid
)
2747 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2748 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2751 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2754 if (old
->actimeo
!= new->actimeo
)
2761 cifs_match_super(struct super_block
*sb
, void *data
)
2763 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2764 struct smb_vol
*volume_info
;
2765 struct cifs_sb_info
*cifs_sb
;
2766 struct TCP_Server_Info
*tcp_srv
;
2767 struct cifs_ses
*ses
;
2768 struct cifs_tcon
*tcon
;
2769 struct tcon_link
*tlink
;
2770 struct sockaddr_storage addr
;
2773 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
2775 spin_lock(&cifs_tcp_ses_lock
);
2776 cifs_sb
= CIFS_SB(sb
);
2777 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2778 if (IS_ERR(tlink
)) {
2779 spin_unlock(&cifs_tcp_ses_lock
);
2782 tcon
= tlink_tcon(tlink
);
2784 tcp_srv
= ses
->server
;
2786 volume_info
= mnt_data
->vol
;
2788 if (!volume_info
->UNCip
|| !volume_info
->UNC
)
2791 rc
= cifs_fill_sockaddr((struct sockaddr
*)&addr
,
2793 strlen(volume_info
->UNCip
),
2798 if (!match_server(tcp_srv
, (struct sockaddr
*)&addr
, volume_info
) ||
2799 !match_session(ses
, volume_info
) ||
2800 !match_tcon(tcon
, volume_info
->UNC
)) {
2805 rc
= compare_mount_options(sb
, mnt_data
);
2807 spin_unlock(&cifs_tcp_ses_lock
);
2808 cifs_put_tlink(tlink
);
2813 get_dfs_path(int xid
, struct cifs_ses
*pSesInfo
, const char *old_path
,
2814 const struct nls_table
*nls_codepage
, unsigned int *pnum_referrals
,
2815 struct dfs_info3_param
**preferrals
, int remap
)
2820 *pnum_referrals
= 0;
2823 if (pSesInfo
->ipc_tid
== 0) {
2824 temp_unc
= kmalloc(2 /* for slashes */ +
2825 strnlen(pSesInfo
->serverName
,
2826 SERVER_NAME_LEN_WITH_NULL
* 2)
2827 + 1 + 4 /* slash IPC$ */ + 2,
2829 if (temp_unc
== NULL
)
2833 strcpy(temp_unc
+ 2, pSesInfo
->serverName
);
2834 strcpy(temp_unc
+ 2 + strlen(pSesInfo
->serverName
), "\\IPC$");
2835 rc
= CIFSTCon(xid
, pSesInfo
, temp_unc
, NULL
, nls_codepage
);
2836 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc
, pSesInfo
->ipc_tid
);
2840 rc
= CIFSGetDFSRefer(xid
, pSesInfo
, old_path
, preferrals
,
2841 pnum_referrals
, nls_codepage
, remap
);
2842 /* BB map targetUNCs to dfs_info3 structures, here or
2843 in CIFSGetDFSRefer BB */
2848 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2849 static struct lock_class_key cifs_key
[2];
2850 static struct lock_class_key cifs_slock_key
[2];
2853 cifs_reclassify_socket4(struct socket
*sock
)
2855 struct sock
*sk
= sock
->sk
;
2856 BUG_ON(sock_owned_by_user(sk
));
2857 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2858 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2862 cifs_reclassify_socket6(struct socket
*sock
)
2864 struct sock
*sk
= sock
->sk
;
2865 BUG_ON(sock_owned_by_user(sk
));
2866 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2867 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2871 cifs_reclassify_socket4(struct socket
*sock
)
2876 cifs_reclassify_socket6(struct socket
*sock
)
2881 /* See RFC1001 section 14 on representation of Netbios names */
2882 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2886 for (i
= 0, j
= 0; i
< (length
); i
++) {
2887 /* mask a nibble at a time and encode */
2888 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2889 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2896 bind_socket(struct TCP_Server_Info
*server
)
2899 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2900 /* Bind to the specified local IP address */
2901 struct socket
*socket
= server
->ssocket
;
2902 rc
= socket
->ops
->bind(socket
,
2903 (struct sockaddr
*) &server
->srcaddr
,
2904 sizeof(server
->srcaddr
));
2906 struct sockaddr_in
*saddr4
;
2907 struct sockaddr_in6
*saddr6
;
2908 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2909 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2910 if (saddr6
->sin6_family
== AF_INET6
)
2912 "Failed to bind to: %pI6c, error: %d\n",
2913 &saddr6
->sin6_addr
, rc
);
2916 "Failed to bind to: %pI4, error: %d\n",
2917 &saddr4
->sin_addr
.s_addr
, rc
);
2924 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2928 * some servers require RFC1001 sessinit before sending
2929 * negprot - BB check reconnection in case where second
2930 * sessinit is sent but no second negprot
2932 struct rfc1002_session_packet
*ses_init_buf
;
2933 struct smb_hdr
*smb_buf
;
2934 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2937 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2939 if (server
->server_RFC1001_name
&&
2940 server
->server_RFC1001_name
[0] != 0)
2941 rfc1002mangle(ses_init_buf
->trailer
.
2942 session_req
.called_name
,
2943 server
->server_RFC1001_name
,
2944 RFC1001_NAME_LEN_WITH_NULL
);
2946 rfc1002mangle(ses_init_buf
->trailer
.
2947 session_req
.called_name
,
2948 DEFAULT_CIFS_CALLED_NAME
,
2949 RFC1001_NAME_LEN_WITH_NULL
);
2951 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
2954 * calling name ends in null (byte 16) from old smb
2957 if (server
->workstation_RFC1001_name
&&
2958 server
->workstation_RFC1001_name
[0] != 0)
2959 rfc1002mangle(ses_init_buf
->trailer
.
2960 session_req
.calling_name
,
2961 server
->workstation_RFC1001_name
,
2962 RFC1001_NAME_LEN_WITH_NULL
);
2964 rfc1002mangle(ses_init_buf
->trailer
.
2965 session_req
.calling_name
,
2967 RFC1001_NAME_LEN_WITH_NULL
);
2969 ses_init_buf
->trailer
.session_req
.scope1
= 0;
2970 ses_init_buf
->trailer
.session_req
.scope2
= 0;
2971 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
2973 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2974 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
2975 rc
= smb_send(server
, smb_buf
, 0x44);
2976 kfree(ses_init_buf
);
2978 * RFC1001 layer in at least one server
2979 * requires very short break before negprot
2980 * presumably because not expecting negprot
2981 * to follow so fast. This is a simple
2982 * solution that works without
2983 * complicating the code and causes no
2984 * significant slowing down on mount
2987 usleep_range(1000, 2000);
2990 * else the negprot may still work without this
2991 * even though malloc failed
2998 generic_ip_connect(struct TCP_Server_Info
*server
)
3003 struct socket
*socket
= server
->ssocket
;
3004 struct sockaddr
*saddr
;
3006 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3008 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3009 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3010 slen
= sizeof(struct sockaddr_in6
);
3013 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3014 slen
= sizeof(struct sockaddr_in
);
3018 if (socket
== NULL
) {
3019 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3020 IPPROTO_TCP
, &socket
, 1);
3022 cERROR(1, "Error %d creating socket", rc
);
3023 server
->ssocket
= NULL
;
3027 /* BB other socket options to set KEEPALIVE, NODELAY? */
3028 cFYI(1, "Socket created");
3029 server
->ssocket
= socket
;
3030 socket
->sk
->sk_allocation
= GFP_NOFS
;
3031 if (sfamily
== AF_INET6
)
3032 cifs_reclassify_socket6(socket
);
3034 cifs_reclassify_socket4(socket
);
3037 rc
= bind_socket(server
);
3042 * Eventually check for other socket options to change from
3043 * the default. sock_setsockopt not used because it expects
3046 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3047 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3049 /* make the bufsizes depend on wsize/rsize and max requests */
3050 if (server
->noautotune
) {
3051 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3052 socket
->sk
->sk_sndbuf
= 200 * 1024;
3053 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3054 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3057 if (server
->tcp_nodelay
) {
3059 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3060 (char *)&val
, sizeof(val
));
3062 cFYI(1, "set TCP_NODELAY socket option error %d", rc
);
3065 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3066 socket
->sk
->sk_sndbuf
,
3067 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3069 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3071 cFYI(1, "Error %d connecting to server", rc
);
3072 sock_release(socket
);
3073 server
->ssocket
= NULL
;
3077 if (sport
== htons(RFC1001_PORT
))
3078 rc
= ip_rfc1001_connect(server
);
3084 ip_connect(struct TCP_Server_Info
*server
)
3087 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3088 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3090 if (server
->dstaddr
.ss_family
== AF_INET6
)
3091 sport
= &addr6
->sin6_port
;
3093 sport
= &addr
->sin_port
;
3098 /* try with 445 port at first */
3099 *sport
= htons(CIFS_PORT
);
3101 rc
= generic_ip_connect(server
);
3105 /* if it failed, try with 139 port */
3106 *sport
= htons(RFC1001_PORT
);
3109 return generic_ip_connect(server
);
3112 void reset_cifs_unix_caps(int xid
, struct cifs_tcon
*tcon
,
3113 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3115 /* if we are reconnecting then should we check to see if
3116 * any requested capabilities changed locally e.g. via
3117 * remount but we can not do much about it here
3118 * if they have (even if we could detect it by the following)
3119 * Perhaps we could add a backpointer to array of sb from tcon
3120 * or if we change to make all sb to same share the same
3121 * sb as NFS - then we only have one backpointer to sb.
3122 * What if we wanted to mount the server share twice once with
3123 * and once without posixacls or posix paths? */
3124 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3126 if (vol_info
&& vol_info
->no_linux_ext
) {
3127 tcon
->fsUnixInfo
.Capability
= 0;
3128 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3129 cFYI(1, "Linux protocol extensions disabled");
3131 } else if (vol_info
)
3132 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3134 if (tcon
->unix_ext
== 0) {
3135 cFYI(1, "Unix extensions disabled so not set on reconnect");
3139 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3140 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3141 cFYI(1, "unix caps which server supports %lld", cap
);
3142 /* check for reconnect case in which we do not
3143 want to change the mount behavior if we can avoid it */
3144 if (vol_info
== NULL
) {
3145 /* turn off POSIX ACL and PATHNAMES if not set
3146 originally at mount time */
3147 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3148 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3149 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3150 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3151 cERROR(1, "POSIXPATH support change");
3152 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3153 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3154 cERROR(1, "possible reconnect error");
3155 cERROR(1, "server disabled POSIX path support");
3159 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3160 cERROR(1, "per-share encryption not supported yet");
3162 cap
&= CIFS_UNIX_CAP_MASK
;
3163 if (vol_info
&& vol_info
->no_psx_acl
)
3164 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3165 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3166 cFYI(1, "negotiated posix acl support");
3168 cifs_sb
->mnt_cifs_flags
|=
3169 CIFS_MOUNT_POSIXACL
;
3172 if (vol_info
&& vol_info
->posix_paths
== 0)
3173 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3174 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3175 cFYI(1, "negotiate posix pathnames");
3177 cifs_sb
->mnt_cifs_flags
|=
3178 CIFS_MOUNT_POSIX_PATHS
;
3181 cFYI(1, "Negotiate caps 0x%x", (int)cap
);
3182 #ifdef CONFIG_CIFS_DEBUG2
3183 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3184 cFYI(1, "FCNTL cap");
3185 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3186 cFYI(1, "EXTATTR cap");
3187 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3188 cFYI(1, "POSIX path cap");
3189 if (cap
& CIFS_UNIX_XATTR_CAP
)
3190 cFYI(1, "XATTR cap");
3191 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3192 cFYI(1, "POSIX ACL cap");
3193 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3194 cFYI(1, "very large read cap");
3195 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3196 cFYI(1, "very large write cap");
3197 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3198 cFYI(1, "transport encryption cap");
3199 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3200 cFYI(1, "mandatory transport encryption cap");
3201 #endif /* CIFS_DEBUG2 */
3202 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3203 if (vol_info
== NULL
) {
3204 cFYI(1, "resetting capabilities failed");
3206 cERROR(1, "Negotiating Unix capabilities "
3207 "with the server failed. Consider "
3208 "mounting with the Unix Extensions\n"
3209 "disabled, if problems are found, "
3210 "by specifying the nounix mount "
3217 void cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3218 struct cifs_sb_info
*cifs_sb
)
3220 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3222 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3223 cifs_sb
->tlink_tree
= RB_ROOT
;
3226 * Temporarily set r/wsize for matching superblock. If we end up using
3227 * new sb then client will later negotiate it downward if needed.
3229 cifs_sb
->rsize
= pvolume_info
->rsize
;
3230 cifs_sb
->wsize
= pvolume_info
->wsize
;
3232 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3233 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3234 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3235 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3236 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3237 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3239 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3240 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3242 if (pvolume_info
->noperm
)
3243 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3244 if (pvolume_info
->setuids
)
3245 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3246 if (pvolume_info
->server_ino
)
3247 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3248 if (pvolume_info
->remap
)
3249 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3250 if (pvolume_info
->no_xattr
)
3251 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3252 if (pvolume_info
->sfu_emul
)
3253 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3254 if (pvolume_info
->nobrl
)
3255 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3256 if (pvolume_info
->nostrictsync
)
3257 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3258 if (pvolume_info
->mand_lock
)
3259 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3260 if (pvolume_info
->rwpidforward
)
3261 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3262 if (pvolume_info
->cifs_acl
)
3263 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3264 if (pvolume_info
->backupuid_specified
) {
3265 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3266 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3268 if (pvolume_info
->backupgid_specified
) {
3269 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3270 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3272 if (pvolume_info
->override_uid
)
3273 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3274 if (pvolume_info
->override_gid
)
3275 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3276 if (pvolume_info
->dynperm
)
3277 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3278 if (pvolume_info
->fsc
)
3279 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3280 if (pvolume_info
->multiuser
)
3281 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3282 CIFS_MOUNT_NO_PERM
);
3283 if (pvolume_info
->strict_io
)
3284 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3285 if (pvolume_info
->direct_io
) {
3286 cFYI(1, "mounting share using direct i/o");
3287 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3289 if (pvolume_info
->mfsymlinks
) {
3290 if (pvolume_info
->sfu_emul
) {
3291 cERROR(1, "mount option mfsymlinks ignored if sfu "
3292 "mount option is used");
3294 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3298 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3299 cERROR(1, "mount option dynperm ignored if cifsacl "
3300 "mount option supported");
3304 * When the server supports very large reads and writes via POSIX extensions,
3305 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3306 * including the RFC1001 length.
3308 * Note that this might make for "interesting" allocation problems during
3309 * writeback however as we have to allocate an array of pointers for the
3310 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3312 * For reads, there is a similar problem as we need to allocate an array
3313 * of kvecs to handle the receive, though that should only need to be done
3316 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3317 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3320 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3321 * of 2^17-1 minus the size of the call header. That allows for a read or
3322 * write up to the maximum size described by RFC1002.
3324 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3325 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3328 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3329 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3330 * a single wsize request with a single call.
3332 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3335 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3336 * those values when posix extensions aren't in force. In actuality here, we
3337 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3338 * to be ok with the extra byte even though Windows doesn't send writes that
3343 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3345 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3346 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3349 cifs_negotiate_wsize(struct cifs_tcon
*tcon
, struct smb_vol
*pvolume_info
)
3351 __u64 unix_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3352 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
3355 /* start with specified wsize, or default */
3356 if (pvolume_info
->wsize
)
3357 wsize
= pvolume_info
->wsize
;
3358 else if (tcon
->unix_ext
&& (unix_cap
& CIFS_UNIX_LARGE_WRITE_CAP
))
3359 wsize
= CIFS_DEFAULT_IOSIZE
;
3361 wsize
= CIFS_DEFAULT_NON_POSIX_WSIZE
;
3363 /* can server support 24-bit write sizes? (via UNIX extensions) */
3364 if (!tcon
->unix_ext
|| !(unix_cap
& CIFS_UNIX_LARGE_WRITE_CAP
))
3365 wsize
= min_t(unsigned int, wsize
, CIFS_MAX_RFC1002_WSIZE
);
3368 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3369 * Limit it to max buffer offered by the server, minus the size of the
3370 * WRITEX header, not including the 4 byte RFC1001 length.
3372 if (!(server
->capabilities
& CAP_LARGE_WRITE_X
) ||
3373 (!(server
->capabilities
& CAP_UNIX
) &&
3374 (server
->sec_mode
& (SECMODE_SIGN_ENABLED
|SECMODE_SIGN_REQUIRED
))))
3375 wsize
= min_t(unsigned int, wsize
,
3376 server
->maxBuf
- sizeof(WRITE_REQ
) + 4);
3378 /* hard limit of CIFS_MAX_WSIZE */
3379 wsize
= min_t(unsigned int, wsize
, CIFS_MAX_WSIZE
);
3385 cifs_negotiate_rsize(struct cifs_tcon
*tcon
, struct smb_vol
*pvolume_info
)
3387 __u64 unix_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3388 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
3389 unsigned int rsize
, defsize
;
3392 * Set default value...
3394 * HACK alert! Ancient servers have very small buffers. Even though
3395 * MS-CIFS indicates that servers are only limited by the client's
3396 * bufsize for reads, testing against win98se shows that it throws
3397 * INVALID_PARAMETER errors if you try to request too large a read.
3399 * If the server advertises a MaxBufferSize of less than one page,
3400 * assume that it also can't satisfy reads larger than that either.
3402 * FIXME: Is there a better heuristic for this?
3404 if (tcon
->unix_ext
&& (unix_cap
& CIFS_UNIX_LARGE_READ_CAP
))
3405 defsize
= CIFS_DEFAULT_IOSIZE
;
3406 else if (server
->capabilities
& CAP_LARGE_READ_X
)
3407 defsize
= CIFS_DEFAULT_NON_POSIX_RSIZE
;
3408 else if (server
->maxBuf
>= PAGE_CACHE_SIZE
)
3409 defsize
= CIFSMaxBufSize
;
3411 defsize
= server
->maxBuf
- sizeof(READ_RSP
);
3413 rsize
= pvolume_info
->rsize
? pvolume_info
->rsize
: defsize
;
3416 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3417 * the client's MaxBufferSize.
3419 if (!(server
->capabilities
& CAP_LARGE_READ_X
))
3420 rsize
= min_t(unsigned int, CIFSMaxBufSize
, rsize
);
3422 /* hard limit of CIFS_MAX_RSIZE */
3423 rsize
= min_t(unsigned int, rsize
, CIFS_MAX_RSIZE
);
3429 is_path_accessible(int xid
, struct cifs_tcon
*tcon
,
3430 struct cifs_sb_info
*cifs_sb
, const char *full_path
)
3433 FILE_ALL_INFO
*pfile_info
;
3435 pfile_info
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
3436 if (pfile_info
== NULL
)
3439 rc
= CIFSSMBQPathInfo(xid
, tcon
, full_path
, pfile_info
,
3440 0 /* not legacy */, cifs_sb
->local_nls
,
3441 cifs_sb
->mnt_cifs_flags
&
3442 CIFS_MOUNT_MAP_SPECIAL_CHR
);
3444 if (rc
== -EOPNOTSUPP
|| rc
== -EINVAL
)
3445 rc
= SMBQueryInformation(xid
, tcon
, full_path
, pfile_info
,
3446 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
3447 CIFS_MOUNT_MAP_SPECIAL_CHR
);
3453 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3455 kfree(volume_info
->username
);
3456 kzfree(volume_info
->password
);
3457 if (volume_info
->UNCip
!= volume_info
->UNC
+ 2)
3458 kfree(volume_info
->UNCip
);
3459 kfree(volume_info
->UNC
);
3460 kfree(volume_info
->domainname
);
3461 kfree(volume_info
->iocharset
);
3462 kfree(volume_info
->prepath
);
3466 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3470 cleanup_volume_info_contents(volume_info
);
3475 #ifdef CONFIG_CIFS_DFS_UPCALL
3476 /* build_path_to_root returns full path to root when
3477 * we do not have an exiting connection (tcon) */
3479 build_unc_path_to_root(const struct smb_vol
*vol
,
3480 const struct cifs_sb_info
*cifs_sb
)
3482 char *full_path
, *pos
;
3483 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) : 0;
3484 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3486 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3487 if (full_path
== NULL
)
3488 return ERR_PTR(-ENOMEM
);
3490 strncpy(full_path
, vol
->UNC
, unc_len
);
3491 pos
= full_path
+ unc_len
;
3494 strncpy(pos
, vol
->prepath
, pplen
);
3498 *pos
= '\0'; /* add trailing null */
3499 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3500 cFYI(1, "%s: full_path=%s", __func__
, full_path
);
3505 * Perform a dfs referral query for a share and (optionally) prefix
3507 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3508 * to a string containing updated options for the submount. Otherwise it
3509 * will be left untouched.
3511 * Returns the rc from get_dfs_path to the caller, which can be used to
3512 * determine whether there were referrals.
3515 expand_dfs_referral(int xid
, struct cifs_ses
*pSesInfo
,
3516 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3520 unsigned int num_referrals
= 0;
3521 struct dfs_info3_param
*referrals
= NULL
;
3522 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3524 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3525 if (IS_ERR(full_path
))
3526 return PTR_ERR(full_path
);
3528 /* For DFS paths, skip the first '\' of the UNC */
3529 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3531 rc
= get_dfs_path(xid
, pSesInfo
, ref_path
, cifs_sb
->local_nls
,
3532 &num_referrals
, &referrals
,
3533 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
3535 if (!rc
&& num_referrals
> 0) {
3536 char *fake_devname
= NULL
;
3538 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3539 full_path
+ 1, referrals
,
3542 free_dfs_info_array(referrals
, num_referrals
);
3544 if (IS_ERR(mdata
)) {
3545 rc
= PTR_ERR(mdata
);
3548 cleanup_volume_info_contents(volume_info
);
3549 memset(volume_info
, '\0', sizeof(*volume_info
));
3550 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3553 kfree(fake_devname
);
3554 kfree(cifs_sb
->mountdata
);
3555 cifs_sb
->mountdata
= mdata
;
3563 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3564 const char *devname
)
3568 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3571 if (volume_info
->nullauth
) {
3572 cFYI(1, "Anonymous login");
3573 kfree(volume_info
->username
);
3574 volume_info
->username
= NULL
;
3575 } else if (volume_info
->username
) {
3576 /* BB fixme parse for domain name here */
3577 cFYI(1, "Username: %s", volume_info
->username
);
3579 cifserror("No username specified");
3580 /* In userspace mount helper we can get user name from alternate
3581 locations such as env variables and files on disk */
3585 /* this is needed for ASCII cp to Unicode converts */
3586 if (volume_info
->iocharset
== NULL
) {
3587 /* load_nls_default cannot return null */
3588 volume_info
->local_nls
= load_nls_default();
3590 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3591 if (volume_info
->local_nls
== NULL
) {
3592 cERROR(1, "CIFS mount error: iocharset %s not found",
3593 volume_info
->iocharset
);
3602 cifs_get_volume_info(char *mount_data
, const char *devname
)
3605 struct smb_vol
*volume_info
;
3607 volume_info
= kzalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3609 return ERR_PTR(-ENOMEM
);
3611 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3613 cifs_cleanup_volume_info(volume_info
);
3614 volume_info
= ERR_PTR(rc
);
3621 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3625 struct cifs_ses
*pSesInfo
;
3626 struct cifs_tcon
*tcon
;
3627 struct TCP_Server_Info
*srvTcp
;
3629 struct tcon_link
*tlink
;
3630 #ifdef CONFIG_CIFS_DFS_UPCALL
3631 int referral_walks_count
= 0;
3634 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs", BDI_CAP_MAP_COPY
);
3638 #ifdef CONFIG_CIFS_DFS_UPCALL
3640 /* cleanup activities if we're chasing a referral */
3641 if (referral_walks_count
) {
3643 cifs_put_tcon(tcon
);
3645 cifs_put_smb_ses(pSesInfo
);
3659 /* get a reference to a tcp session */
3660 srvTcp
= cifs_get_tcp_session(volume_info
);
3661 if (IS_ERR(srvTcp
)) {
3662 rc
= PTR_ERR(srvTcp
);
3663 bdi_destroy(&cifs_sb
->bdi
);
3667 /* get a reference to a SMB session */
3668 pSesInfo
= cifs_get_smb_ses(srvTcp
, volume_info
);
3669 if (IS_ERR(pSesInfo
)) {
3670 rc
= PTR_ERR(pSesInfo
);
3672 goto mount_fail_check
;
3675 /* search for existing tcon to this server share */
3676 tcon
= cifs_get_tcon(pSesInfo
, volume_info
);
3680 goto remote_path_check
;
3683 /* tell server which Unix caps we support */
3684 if (tcon
->ses
->capabilities
& CAP_UNIX
) {
3685 /* reset of caps checks mount to see if unix extensions
3686 disabled for just this mount */
3687 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3688 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3689 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3690 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3692 goto mount_fail_check
;
3695 tcon
->unix_ext
= 0; /* server does not support them */
3697 /* do not care if following two calls succeed - informational */
3699 CIFSSMBQFSDeviceInfo(xid
, tcon
);
3700 CIFSSMBQFSAttributeInfo(xid
, tcon
);
3703 cifs_sb
->wsize
= cifs_negotiate_wsize(tcon
, volume_info
);
3704 cifs_sb
->rsize
= cifs_negotiate_rsize(tcon
, volume_info
);
3706 /* tune readahead according to rsize */
3707 cifs_sb
->bdi
.ra_pages
= cifs_sb
->rsize
/ PAGE_CACHE_SIZE
;
3710 #ifdef CONFIG_CIFS_DFS_UPCALL
3712 * Perform an unconditional check for whether there are DFS
3713 * referrals for this path without prefix, to provide support
3714 * for DFS referrals from w2k8 servers which don't seem to respond
3715 * with PATH_NOT_COVERED to requests that include the prefix.
3716 * Chase the referral if found, otherwise continue normally.
3718 if (referral_walks_count
== 0) {
3719 int refrc
= expand_dfs_referral(xid
, pSesInfo
, volume_info
,
3722 referral_walks_count
++;
3723 goto try_mount_again
;
3728 /* check if a whole path is not remote */
3730 /* build_path_to_root works only when we have a valid tcon */
3731 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3732 if (full_path
== NULL
) {
3734 goto mount_fail_check
;
3736 rc
= is_path_accessible(xid
, tcon
, cifs_sb
, full_path
);
3737 if (rc
!= 0 && rc
!= -EREMOTE
) {
3739 goto mount_fail_check
;
3744 /* get referral if needed */
3745 if (rc
== -EREMOTE
) {
3746 #ifdef CONFIG_CIFS_DFS_UPCALL
3747 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3749 * BB: when we implement proper loop detection,
3750 * we will remove this check. But now we need it
3751 * to prevent an indefinite loop if 'DFS tree' is
3752 * misconfigured (i.e. has loops).
3755 goto mount_fail_check
;
3758 rc
= expand_dfs_referral(xid
, pSesInfo
, volume_info
, cifs_sb
,
3762 referral_walks_count
++;
3763 goto try_mount_again
;
3765 goto mount_fail_check
;
3766 #else /* No DFS support, return error on mount */
3772 goto mount_fail_check
;
3774 /* now, hang the tcon off of the superblock */
3775 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3776 if (tlink
== NULL
) {
3778 goto mount_fail_check
;
3781 tlink
->tl_uid
= pSesInfo
->linux_uid
;
3782 tlink
->tl_tcon
= tcon
;
3783 tlink
->tl_time
= jiffies
;
3784 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3785 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3787 cifs_sb
->master_tlink
= tlink
;
3788 spin_lock(&cifs_sb
->tlink_tree_lock
);
3789 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3790 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3792 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3796 /* on error free sesinfo and tcon struct if needed */
3798 /* If find_unc succeeded then rc == 0 so we can not end */
3799 /* up accidentally freeing someone elses tcon struct */
3801 cifs_put_tcon(tcon
);
3803 cifs_put_smb_ses(pSesInfo
);
3805 cifs_put_tcp_session(srvTcp
);
3806 bdi_destroy(&cifs_sb
->bdi
);
3815 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3816 * pointer may be NULL.
3819 CIFSTCon(unsigned int xid
, struct cifs_ses
*ses
,
3820 const char *tree
, struct cifs_tcon
*tcon
,
3821 const struct nls_table
*nls_codepage
)
3823 struct smb_hdr
*smb_buffer
;
3824 struct smb_hdr
*smb_buffer_response
;
3827 unsigned char *bcc_ptr
;
3830 __u16 bytes_left
, count
;
3835 smb_buffer
= cifs_buf_get();
3836 if (smb_buffer
== NULL
)
3839 smb_buffer_response
= smb_buffer
;
3841 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3842 NULL
/*no tid */ , 4 /*wct */ );
3844 smb_buffer
->Mid
= GetNextMid(ses
->server
);
3845 smb_buffer
->Uid
= ses
->Suid
;
3846 pSMB
= (TCONX_REQ
*) smb_buffer
;
3847 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3849 pSMB
->AndXCommand
= 0xFF;
3850 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3851 bcc_ptr
= &pSMB
->Password
[0];
3852 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3853 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3854 *bcc_ptr
= 0; /* password is null byte */
3855 bcc_ptr
++; /* skip password */
3856 /* already aligned so no need to do it below */
3858 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3859 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3860 specified as required (when that support is added to
3861 the vfs in the future) as only NTLM or the much
3862 weaker LANMAN (which we do not send by default) is accepted
3863 by Samba (not sure whether other servers allow
3864 NTLMv2 password here) */
3865 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3866 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3867 (ses
->server
->secType
== LANMAN
))
3868 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3869 ses
->server
->sec_mode
&
3870 SECMODE_PW_ENCRYPT
? true : false,
3873 #endif /* CIFS_WEAK_PW_HASH */
3874 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3875 bcc_ptr
, nls_codepage
);
3877 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3878 if (ses
->capabilities
& CAP_UNICODE
) {
3879 /* must align unicode strings */
3880 *bcc_ptr
= 0; /* null byte password */
3885 if (ses
->server
->sec_mode
&
3886 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
3887 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3889 if (ses
->capabilities
& CAP_STATUS32
) {
3890 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3892 if (ses
->capabilities
& CAP_DFS
) {
3893 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3895 if (ses
->capabilities
& CAP_UNICODE
) {
3896 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3898 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
3899 6 /* max utf8 char length in bytes */ *
3900 (/* server len*/ + 256 /* share len */), nls_codepage
);
3901 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3902 bcc_ptr
+= 2; /* skip trailing null */
3903 } else { /* ASCII */
3904 strcpy(bcc_ptr
, tree
);
3905 bcc_ptr
+= strlen(tree
) + 1;
3907 strcpy(bcc_ptr
, "?????");
3908 bcc_ptr
+= strlen("?????");
3910 count
= bcc_ptr
- &pSMB
->Password
[0];
3911 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3912 pSMB
->hdr
.smb_buf_length
) + count
);
3913 pSMB
->ByteCount
= cpu_to_le16(count
);
3915 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3918 /* above now done in SendReceive */
3919 if ((rc
== 0) && (tcon
!= NULL
)) {
3922 tcon
->tidStatus
= CifsGood
;
3923 tcon
->need_reconnect
= false;
3924 tcon
->tid
= smb_buffer_response
->Tid
;
3925 bcc_ptr
= pByteArea(smb_buffer_response
);
3926 bytes_left
= get_bcc(smb_buffer_response
);
3927 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3928 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3934 /* skip service field (NB: this field is always ASCII) */
3936 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3937 (bcc_ptr
[2] == 'C')) {
3938 cFYI(1, "IPC connection");
3941 } else if (length
== 2) {
3942 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3943 /* the most common case */
3944 cFYI(1, "disk share connection");
3947 bcc_ptr
+= length
+ 1;
3948 bytes_left
-= (length
+ 1);
3949 strncpy(tcon
->treeName
, tree
, MAX_TREE_SIZE
);
3951 /* mostly informational -- no need to fail on error here */
3952 kfree(tcon
->nativeFileSystem
);
3953 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
3954 bytes_left
, is_unicode
,
3957 cFYI(1, "nativeFileSystem=%s", tcon
->nativeFileSystem
);
3959 if ((smb_buffer_response
->WordCount
== 3) ||
3960 (smb_buffer_response
->WordCount
== 7))
3961 /* field is in same location */
3962 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3965 cFYI(1, "Tcon flags: 0x%x ", tcon
->Flags
);
3966 } else if ((rc
== 0) && tcon
== NULL
) {
3967 /* all we need to save for IPC$ connection */
3968 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3971 cifs_buf_release(smb_buffer
);
3976 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3978 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3979 struct rb_node
*node
;
3980 struct tcon_link
*tlink
;
3982 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3984 spin_lock(&cifs_sb
->tlink_tree_lock
);
3985 while ((node
= rb_first(root
))) {
3986 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3987 cifs_get_tlink(tlink
);
3988 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3989 rb_erase(node
, root
);
3991 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3992 cifs_put_tlink(tlink
);
3993 spin_lock(&cifs_sb
->tlink_tree_lock
);
3995 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3997 bdi_destroy(&cifs_sb
->bdi
);
3998 kfree(cifs_sb
->mountdata
);
3999 unload_nls(cifs_sb
->local_nls
);
4003 int cifs_negotiate_protocol(unsigned int xid
, struct cifs_ses
*ses
)
4006 struct TCP_Server_Info
*server
= ses
->server
;
4008 /* only send once per connect */
4009 if (server
->maxBuf
!= 0)
4012 cifs_set_credits(server
, 1);
4013 rc
= CIFSSMBNegotiate(xid
, ses
);
4014 if (rc
== -EAGAIN
) {
4015 /* retry only once on 1st time connection */
4016 cifs_set_credits(server
, 1);
4017 rc
= CIFSSMBNegotiate(xid
, ses
);
4022 spin_lock(&GlobalMid_Lock
);
4023 if (server
->tcpStatus
== CifsNeedNegotiate
)
4024 server
->tcpStatus
= CifsGood
;
4027 spin_unlock(&GlobalMid_Lock
);
4035 int cifs_setup_session(unsigned int xid
, struct cifs_ses
*ses
,
4036 struct nls_table
*nls_info
)
4039 struct TCP_Server_Info
*server
= ses
->server
;
4042 ses
->capabilities
= server
->capabilities
;
4043 if (linuxExtEnabled
== 0)
4044 ses
->capabilities
&= (~CAP_UNIX
);
4046 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4047 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
4049 rc
= CIFS_SessSetup(xid
, ses
, nls_info
);
4051 cERROR(1, "Send error in SessSetup = %d", rc
);
4053 mutex_lock(&ses
->server
->srv_mutex
);
4054 if (!server
->session_estab
) {
4055 server
->session_key
.response
= ses
->auth_key
.response
;
4056 server
->session_key
.len
= ses
->auth_key
.len
;
4057 server
->sequence_number
= 0x2;
4058 server
->session_estab
= true;
4059 ses
->auth_key
.response
= NULL
;
4061 mutex_unlock(&server
->srv_mutex
);
4063 cFYI(1, "CIFS Session Established successfully");
4064 spin_lock(&GlobalMid_Lock
);
4065 ses
->status
= CifsGood
;
4066 ses
->need_reconnect
= false;
4067 spin_unlock(&GlobalMid_Lock
);
4070 kfree(ses
->auth_key
.response
);
4071 ses
->auth_key
.response
= NULL
;
4072 ses
->auth_key
.len
= 0;
4073 kfree(ses
->ntlmssp
);
4074 ses
->ntlmssp
= NULL
;
4080 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
4082 switch (ses
->server
->secType
) {
4084 vol
->secFlg
= CIFSSEC_MUST_KRB5
;
4087 vol
->secFlg
= CIFSSEC_MUST_NTLMV2
;
4090 vol
->secFlg
= CIFSSEC_MUST_NTLM
;
4093 vol
->secFlg
= CIFSSEC_MUST_NTLMSSP
;
4096 vol
->secFlg
= CIFSSEC_MUST_LANMAN
;
4100 return cifs_set_cifscreds(vol
, ses
);
4103 static struct cifs_tcon
*
4104 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, uid_t fsuid
)
4107 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
4108 struct cifs_ses
*ses
;
4109 struct cifs_tcon
*tcon
= NULL
;
4110 struct smb_vol
*vol_info
;
4112 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
4113 if (vol_info
== NULL
)
4114 return ERR_PTR(-ENOMEM
);
4116 vol_info
->local_nls
= cifs_sb
->local_nls
;
4117 vol_info
->linux_uid
= fsuid
;
4118 vol_info
->cred_uid
= fsuid
;
4119 vol_info
->UNC
= master_tcon
->treeName
;
4120 vol_info
->retry
= master_tcon
->retry
;
4121 vol_info
->nocase
= master_tcon
->nocase
;
4122 vol_info
->local_lease
= master_tcon
->local_lease
;
4123 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
4125 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
4131 /* get a reference for the same TCP session */
4132 spin_lock(&cifs_tcp_ses_lock
);
4133 ++master_tcon
->ses
->server
->srv_count
;
4134 spin_unlock(&cifs_tcp_ses_lock
);
4136 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
4138 tcon
= (struct cifs_tcon
*)ses
;
4139 cifs_put_tcp_session(master_tcon
->ses
->server
);
4143 tcon
= cifs_get_tcon(ses
, vol_info
);
4145 cifs_put_smb_ses(ses
);
4149 if (ses
->capabilities
& CAP_UNIX
)
4150 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
4152 kfree(vol_info
->username
);
4153 kfree(vol_info
->password
);
4160 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
4162 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
4166 cifs_sb_tcon_pending_wait(void *unused
)
4169 return signal_pending(current
) ? -ERESTARTSYS
: 0;
4172 /* find and return a tlink with given uid */
4173 static struct tcon_link
*
4174 tlink_rb_search(struct rb_root
*root
, uid_t uid
)
4176 struct rb_node
*node
= root
->rb_node
;
4177 struct tcon_link
*tlink
;
4180 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4182 if (tlink
->tl_uid
> uid
)
4183 node
= node
->rb_left
;
4184 else if (tlink
->tl_uid
< uid
)
4185 node
= node
->rb_right
;
4192 /* insert a tcon_link into the tree */
4194 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
4196 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
4197 struct tcon_link
*tlink
;
4200 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4203 if (tlink
->tl_uid
> new_tlink
->tl_uid
)
4204 new = &((*new)->rb_left
);
4206 new = &((*new)->rb_right
);
4209 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4210 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4214 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4217 * If the superblock doesn't refer to a multiuser mount, then just return
4218 * the master tcon for the mount.
4220 * First, search the rbtree for an existing tcon for this fsuid. If one
4221 * exists, then check to see if it's pending construction. If it is then wait
4222 * for construction to complete. Once it's no longer pending, check to see if
4223 * it failed and either return an error or retry construction, depending on
4226 * If one doesn't exist then insert a new tcon_link struct into the tree and
4227 * try to construct a new one.
4230 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4233 uid_t fsuid
= current_fsuid();
4234 struct tcon_link
*tlink
, *newtlink
;
4236 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4237 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4239 spin_lock(&cifs_sb
->tlink_tree_lock
);
4240 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4242 cifs_get_tlink(tlink
);
4243 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4245 if (tlink
== NULL
) {
4246 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4247 if (newtlink
== NULL
)
4248 return ERR_PTR(-ENOMEM
);
4249 newtlink
->tl_uid
= fsuid
;
4250 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4251 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4252 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4253 cifs_get_tlink(newtlink
);
4255 spin_lock(&cifs_sb
->tlink_tree_lock
);
4256 /* was one inserted after previous search? */
4257 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4259 cifs_get_tlink(tlink
);
4260 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4262 goto wait_for_construction
;
4265 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4266 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4268 wait_for_construction
:
4269 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4270 cifs_sb_tcon_pending_wait
,
4271 TASK_INTERRUPTIBLE
);
4273 cifs_put_tlink(tlink
);
4274 return ERR_PTR(ret
);
4277 /* if it's good, return it */
4278 if (!IS_ERR(tlink
->tl_tcon
))
4281 /* return error if we tried this already recently */
4282 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4283 cifs_put_tlink(tlink
);
4284 return ERR_PTR(-EACCES
);
4287 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4288 goto wait_for_construction
;
4291 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4292 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4293 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4295 if (IS_ERR(tlink
->tl_tcon
)) {
4296 cifs_put_tlink(tlink
);
4297 return ERR_PTR(-EACCES
);
4304 * periodic workqueue job that scans tcon_tree for a superblock and closes
4308 cifs_prune_tlinks(struct work_struct
*work
)
4310 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4312 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4313 struct rb_node
*node
= rb_first(root
);
4314 struct rb_node
*tmp
;
4315 struct tcon_link
*tlink
;
4318 * Because we drop the spinlock in the loop in order to put the tlink
4319 * it's not guarded against removal of links from the tree. The only
4320 * places that remove entries from the tree are this function and
4321 * umounts. Because this function is non-reentrant and is canceled
4322 * before umount can proceed, this is safe.
4324 spin_lock(&cifs_sb
->tlink_tree_lock
);
4325 node
= rb_first(root
);
4326 while (node
!= NULL
) {
4328 node
= rb_next(tmp
);
4329 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4331 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4332 atomic_read(&tlink
->tl_count
) != 0 ||
4333 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4336 cifs_get_tlink(tlink
);
4337 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4338 rb_erase(tmp
, root
);
4340 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4341 cifs_put_tlink(tlink
);
4342 spin_lock(&cifs_sb
->tlink_tree_lock
);
4344 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4346 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,