4 * Copyright (C) International Business Machines Corp., 2002,2011
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>
44 #include <linux/bvec.h>
48 #include "cifsproto.h"
49 #include "cifs_unicode.h"
50 #include "cifs_debug.h"
51 #include "cifs_fs_sb.h"
54 #include "rfc1002pdu.h"
58 #define RFC1001_PORT 139
60 extern mempool_t
*cifs_req_poolp
;
62 /* FIXME: should these be tunable? */
63 #define TLINK_ERROR_EXPIRE (1 * HZ)
64 #define TLINK_IDLE_EXPIRE (600 * HZ)
67 /* Mount options that take no arguments */
68 Opt_user_xattr
, Opt_nouser_xattr
,
69 Opt_forceuid
, Opt_noforceuid
,
70 Opt_forcegid
, Opt_noforcegid
,
71 Opt_noblocksend
, Opt_noautotune
,
72 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
,
73 Opt_mapposix
, Opt_nomapposix
,
74 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
75 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
76 Opt_noposixpaths
, Opt_nounix
,
79 Opt_forcemandatorylock
, Opt_setuidfromacl
, Opt_setuids
,
80 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
81 Opt_nohard
, Opt_nosoft
,
83 Opt_nostrictsync
, Opt_strictsync
,
84 Opt_serverino
, Opt_noserverino
,
85 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
86 Opt_acl
, Opt_noacl
, Opt_locallease
,
87 Opt_sign
, Opt_seal
, Opt_noac
,
88 Opt_fsc
, Opt_mfsymlinks
,
89 Opt_multiuser
, Opt_sloppy
, Opt_nosharesock
,
90 Opt_persistent
, Opt_nopersistent
,
91 Opt_resilient
, Opt_noresilient
,
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
,
98 Opt_echo_interval
, Opt_max_credits
,
100 /* Mount options which take string value */
101 Opt_user
, Opt_pass
, Opt_ip
,
102 Opt_domain
, Opt_srcaddr
, Opt_iocharset
,
103 Opt_netbiosname
, Opt_servern
,
104 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
106 /* Mount options to be ignored */
109 /* Options which could be blank */
117 static const match_table_t cifs_mount_option_tokens
= {
119 { Opt_user_xattr
, "user_xattr" },
120 { Opt_nouser_xattr
, "nouser_xattr" },
121 { Opt_forceuid
, "forceuid" },
122 { Opt_noforceuid
, "noforceuid" },
123 { Opt_forcegid
, "forcegid" },
124 { Opt_noforcegid
, "noforcegid" },
125 { Opt_noblocksend
, "noblocksend" },
126 { Opt_noautotune
, "noautotune" },
127 { Opt_hard
, "hard" },
128 { Opt_soft
, "soft" },
129 { Opt_perm
, "perm" },
130 { Opt_noperm
, "noperm" },
131 { Opt_mapchars
, "mapchars" }, /* SFU style */
132 { Opt_nomapchars
, "nomapchars" },
133 { Opt_mapposix
, "mapposix" }, /* SFM style */
134 { Opt_nomapposix
, "nomapposix" },
136 { Opt_nosfu
, "nosfu" },
137 { Opt_nodfs
, "nodfs" },
138 { Opt_posixpaths
, "posixpaths" },
139 { Opt_noposixpaths
, "noposixpaths" },
140 { Opt_nounix
, "nounix" },
141 { Opt_nounix
, "nolinux" },
142 { Opt_nocase
, "nocase" },
143 { Opt_nocase
, "ignorecase" },
145 { Opt_nobrl
, "nobrl" },
146 { Opt_nobrl
, "nolock" },
147 { Opt_forcemandatorylock
, "forcemandatorylock" },
148 { Opt_forcemandatorylock
, "forcemand" },
149 { Opt_setuids
, "setuids" },
150 { Opt_nosetuids
, "nosetuids" },
151 { Opt_setuidfromacl
, "idsfromsid" },
152 { Opt_dynperm
, "dynperm" },
153 { Opt_nodynperm
, "nodynperm" },
154 { Opt_nohard
, "nohard" },
155 { Opt_nosoft
, "nosoft" },
156 { Opt_nointr
, "nointr" },
157 { Opt_intr
, "intr" },
158 { Opt_nostrictsync
, "nostrictsync" },
159 { Opt_strictsync
, "strictsync" },
160 { Opt_serverino
, "serverino" },
161 { Opt_noserverino
, "noserverino" },
162 { Opt_rwpidforward
, "rwpidforward" },
163 { Opt_cifsacl
, "cifsacl" },
164 { Opt_nocifsacl
, "nocifsacl" },
166 { Opt_noacl
, "noacl" },
167 { Opt_locallease
, "locallease" },
168 { Opt_sign
, "sign" },
169 { Opt_seal
, "seal" },
170 { Opt_noac
, "noac" },
172 { Opt_mfsymlinks
, "mfsymlinks" },
173 { Opt_multiuser
, "multiuser" },
174 { Opt_sloppy
, "sloppy" },
175 { Opt_nosharesock
, "nosharesock" },
176 { Opt_persistent
, "persistenthandles"},
177 { Opt_nopersistent
, "nopersistenthandles"},
178 { Opt_resilient
, "resilienthandles"},
179 { Opt_noresilient
, "noresilienthandles"},
181 { Opt_backupuid
, "backupuid=%s" },
182 { Opt_backupgid
, "backupgid=%s" },
183 { Opt_uid
, "uid=%s" },
184 { Opt_cruid
, "cruid=%s" },
185 { Opt_gid
, "gid=%s" },
186 { Opt_file_mode
, "file_mode=%s" },
187 { Opt_dirmode
, "dirmode=%s" },
188 { Opt_dirmode
, "dir_mode=%s" },
189 { Opt_port
, "port=%s" },
190 { Opt_rsize
, "rsize=%s" },
191 { Opt_wsize
, "wsize=%s" },
192 { Opt_actimeo
, "actimeo=%s" },
193 { Opt_echo_interval
, "echo_interval=%s" },
194 { Opt_max_credits
, "max_credits=%s" },
196 { Opt_blank_user
, "user=" },
197 { Opt_blank_user
, "username=" },
198 { Opt_user
, "user=%s" },
199 { Opt_user
, "username=%s" },
200 { Opt_blank_pass
, "pass=" },
201 { Opt_blank_pass
, "password=" },
202 { Opt_pass
, "pass=%s" },
203 { Opt_pass
, "password=%s" },
204 { Opt_blank_ip
, "ip=" },
205 { Opt_blank_ip
, "addr=" },
207 { Opt_ip
, "addr=%s" },
208 { Opt_ignore
, "unc=%s" },
209 { Opt_ignore
, "target=%s" },
210 { Opt_ignore
, "path=%s" },
211 { Opt_domain
, "dom=%s" },
212 { Opt_domain
, "domain=%s" },
213 { Opt_domain
, "workgroup=%s" },
214 { Opt_srcaddr
, "srcaddr=%s" },
215 { Opt_ignore
, "prefixpath=%s" },
216 { Opt_iocharset
, "iocharset=%s" },
217 { Opt_netbiosname
, "netbiosname=%s" },
218 { Opt_servern
, "servern=%s" },
219 { Opt_ver
, "ver=%s" },
220 { Opt_vers
, "vers=%s" },
221 { Opt_sec
, "sec=%s" },
222 { Opt_cache
, "cache=%s" },
224 { Opt_ignore
, "cred" },
225 { Opt_ignore
, "credentials" },
226 { Opt_ignore
, "cred=%s" },
227 { Opt_ignore
, "credentials=%s" },
228 { Opt_ignore
, "guest" },
229 { Opt_ignore
, "rw" },
230 { Opt_ignore
, "ro" },
231 { Opt_ignore
, "suid" },
232 { Opt_ignore
, "nosuid" },
233 { Opt_ignore
, "exec" },
234 { Opt_ignore
, "noexec" },
235 { Opt_ignore
, "nodev" },
236 { Opt_ignore
, "noauto" },
237 { Opt_ignore
, "dev" },
238 { Opt_ignore
, "mand" },
239 { Opt_ignore
, "nomand" },
240 { Opt_ignore
, "_netdev" },
246 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
247 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
248 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
249 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
255 static const match_table_t cifs_secflavor_tokens
= {
256 { Opt_sec_krb5
, "krb5" },
257 { Opt_sec_krb5i
, "krb5i" },
258 { Opt_sec_krb5p
, "krb5p" },
259 { Opt_sec_ntlmsspi
, "ntlmsspi" },
260 { Opt_sec_ntlmssp
, "ntlmssp" },
261 { Opt_ntlm
, "ntlm" },
262 { Opt_sec_ntlmi
, "ntlmi" },
263 { Opt_sec_ntlmv2
, "nontlm" },
264 { Opt_sec_ntlmv2
, "ntlmv2" },
265 { Opt_sec_ntlmv2i
, "ntlmv2i" },
266 { Opt_sec_lanman
, "lanman" },
267 { Opt_sec_none
, "none" },
269 { Opt_sec_err
, NULL
}
280 static const match_table_t cifs_cacheflavor_tokens
= {
281 { Opt_cache_loose
, "loose" },
282 { Opt_cache_strict
, "strict" },
283 { Opt_cache_none
, "none" },
284 { Opt_cache_err
, NULL
}
287 static const match_table_t cifs_smb_version_tokens
= {
288 { Smb_1
, SMB1_VERSION_STRING
},
289 { Smb_20
, SMB20_VERSION_STRING
},
290 { Smb_21
, SMB21_VERSION_STRING
},
291 { Smb_30
, SMB30_VERSION_STRING
},
292 { Smb_302
, SMB302_VERSION_STRING
},
293 #ifdef CONFIG_CIFS_SMB311
294 { Smb_311
, SMB311_VERSION_STRING
},
295 { Smb_311
, ALT_SMB311_VERSION_STRING
},
297 { Smb_version_err
, NULL
}
300 static int ip_connect(struct TCP_Server_Info
*server
);
301 static int generic_ip_connect(struct TCP_Server_Info
*server
);
302 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
303 static void cifs_prune_tlinks(struct work_struct
*work
);
304 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
305 const char *devname
);
308 * cifs tcp session reconnection
310 * mark tcp session as reconnecting so temporarily locked
311 * mark all smb sessions as reconnecting for tcp session
312 * reconnect tcp session
313 * wake up waiters on reconnection? - (not needed currently)
316 cifs_reconnect(struct TCP_Server_Info
*server
)
319 struct list_head
*tmp
, *tmp2
;
320 struct cifs_ses
*ses
;
321 struct cifs_tcon
*tcon
;
322 struct mid_q_entry
*mid_entry
;
323 struct list_head retry_list
;
325 spin_lock(&GlobalMid_Lock
);
326 if (server
->tcpStatus
== CifsExiting
) {
327 /* the demux thread will exit normally
328 next time through the loop */
329 spin_unlock(&GlobalMid_Lock
);
332 server
->tcpStatus
= CifsNeedReconnect
;
333 spin_unlock(&GlobalMid_Lock
);
335 #ifdef CONFIG_CIFS_SMB2
336 server
->max_read
= 0;
339 cifs_dbg(FYI
, "Reconnecting tcp session\n");
341 /* before reconnecting the tcp session, mark the smb session (uid)
342 and the tid bad so they are not used until reconnected */
343 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
345 spin_lock(&cifs_tcp_ses_lock
);
346 list_for_each(tmp
, &server
->smb_ses_list
) {
347 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
348 ses
->need_reconnect
= true;
350 list_for_each(tmp2
, &ses
->tcon_list
) {
351 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
352 tcon
->need_reconnect
= true;
355 spin_unlock(&cifs_tcp_ses_lock
);
357 /* do not want to be sending data on a socket we are freeing */
358 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
359 mutex_lock(&server
->srv_mutex
);
360 if (server
->ssocket
) {
361 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
362 server
->ssocket
->state
, server
->ssocket
->flags
);
363 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
364 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
365 server
->ssocket
->state
, server
->ssocket
->flags
);
366 sock_release(server
->ssocket
);
367 server
->ssocket
= NULL
;
369 server
->sequence_number
= 0;
370 server
->session_estab
= false;
371 kfree(server
->session_key
.response
);
372 server
->session_key
.response
= NULL
;
373 server
->session_key
.len
= 0;
374 server
->lstrp
= jiffies
;
376 /* mark submitted MIDs for retry and issue callback */
377 INIT_LIST_HEAD(&retry_list
);
378 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
379 spin_lock(&GlobalMid_Lock
);
380 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
381 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
382 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
383 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
384 list_move(&mid_entry
->qhead
, &retry_list
);
386 spin_unlock(&GlobalMid_Lock
);
387 mutex_unlock(&server
->srv_mutex
);
389 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
390 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
391 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
392 list_del_init(&mid_entry
->qhead
);
393 mid_entry
->callback(mid_entry
);
399 /* we should try only the port we connected to before */
400 mutex_lock(&server
->srv_mutex
);
401 rc
= generic_ip_connect(server
);
403 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
404 mutex_unlock(&server
->srv_mutex
);
407 atomic_inc(&tcpSesReconnectCount
);
408 spin_lock(&GlobalMid_Lock
);
409 if (server
->tcpStatus
!= CifsExiting
)
410 server
->tcpStatus
= CifsNeedNegotiate
;
411 spin_unlock(&GlobalMid_Lock
);
412 mutex_unlock(&server
->srv_mutex
);
414 } while (server
->tcpStatus
== CifsNeedReconnect
);
416 if (server
->tcpStatus
== CifsNeedNegotiate
)
417 mod_delayed_work(cifsiod_wq
, &server
->echo
, 0);
423 cifs_echo_request(struct work_struct
*work
)
426 struct TCP_Server_Info
*server
= container_of(work
,
427 struct TCP_Server_Info
, echo
.work
);
428 unsigned long echo_interval
;
431 * If we need to renegotiate, set echo interval to zero to
432 * immediately call echo service where we can renegotiate.
434 if (server
->tcpStatus
== CifsNeedNegotiate
)
437 echo_interval
= server
->echo_interval
;
440 * We cannot send an echo if it is disabled.
441 * Also, no need to ping if we got a response recently.
444 if (server
->tcpStatus
== CifsNeedReconnect
||
445 server
->tcpStatus
== CifsExiting
||
446 server
->tcpStatus
== CifsNew
||
447 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
448 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
451 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
453 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
457 queue_delayed_work(cifsiod_wq
, &server
->echo
, server
->echo_interval
);
461 allocate_buffers(struct TCP_Server_Info
*server
)
463 if (!server
->bigbuf
) {
464 server
->bigbuf
= (char *)cifs_buf_get();
465 if (!server
->bigbuf
) {
466 cifs_dbg(VFS
, "No memory for large SMB response\n");
468 /* retry will check if exiting */
471 } else if (server
->large_buf
) {
472 /* we are reusing a dirty large buf, clear its start */
473 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
476 if (!server
->smallbuf
) {
477 server
->smallbuf
= (char *)cifs_small_buf_get();
478 if (!server
->smallbuf
) {
479 cifs_dbg(VFS
, "No memory for SMB response\n");
481 /* retry will check if exiting */
484 /* beginning of smb buffer is cleared in our buf_get */
486 /* if existing small buf clear beginning */
487 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
494 server_unresponsive(struct TCP_Server_Info
*server
)
497 * We need to wait 2 echo intervals to make sure we handle such
499 * 1s client sends a normal SMB request
500 * 2s client gets a response
501 * 30s echo workqueue job pops, and decides we got a response recently
502 * and don't need to send another
504 * 65s kernel_recvmsg times out, and we see that we haven't gotten
505 * a response in >60s.
507 if (server
->tcpStatus
== CifsGood
&&
508 time_after(jiffies
, server
->lstrp
+ 2 * server
->echo_interval
)) {
509 cifs_dbg(VFS
, "Server %s has not responded in %lu seconds. Reconnecting...\n",
510 server
->hostname
, (2 * server
->echo_interval
) / HZ
);
511 cifs_reconnect(server
);
512 wake_up(&server
->response_q
);
520 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
525 smb_msg
->msg_control
= NULL
;
526 smb_msg
->msg_controllen
= 0;
528 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
531 if (server_unresponsive(server
))
532 return -ECONNABORTED
;
534 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
536 if (server
->tcpStatus
== CifsExiting
)
539 if (server
->tcpStatus
== CifsNeedReconnect
) {
540 cifs_reconnect(server
);
541 return -ECONNABORTED
;
544 if (length
== -ERESTARTSYS
||
548 * Minimum sleep to prevent looping, allowing socket
549 * to clear and app threads to set tcpStatus
550 * CifsNeedReconnect if server hung.
552 usleep_range(1000, 2000);
558 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
559 cifs_reconnect(server
);
560 return -ECONNABORTED
;
567 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
568 unsigned int to_read
)
570 struct msghdr smb_msg
;
571 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
572 iov_iter_kvec(&smb_msg
.msg_iter
, READ
| ITER_KVEC
, &iov
, 1, to_read
);
574 return cifs_readv_from_socket(server
, &smb_msg
);
578 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
579 unsigned int to_read
)
581 struct msghdr smb_msg
;
582 struct bio_vec bv
= {.bv_page
= page
, .bv_len
= to_read
};
583 iov_iter_bvec(&smb_msg
.msg_iter
, READ
| ITER_BVEC
, &bv
, 1, to_read
);
584 return cifs_readv_from_socket(server
, &smb_msg
);
588 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
591 * The first byte big endian of the length field,
592 * is actually not part of the length but the type
593 * with the most common, zero, as regular data.
596 case RFC1002_SESSION_MESSAGE
:
597 /* Regular SMB response */
599 case RFC1002_SESSION_KEEP_ALIVE
:
600 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
602 case RFC1002_POSITIVE_SESSION_RESPONSE
:
603 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
605 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
607 * We get this from Windows 98 instead of an error on
608 * SMB negprot response.
610 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
611 /* give server a second to clean up */
614 * Always try 445 first on reconnect since we get NACK
615 * on some if we ever connected to port 139 (the NACK
616 * is since we do not begin with RFC1001 session
619 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
620 cifs_reconnect(server
);
621 wake_up(&server
->response_q
);
624 cifs_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
625 cifs_reconnect(server
);
632 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
634 #ifdef CONFIG_CIFS_STATS2
635 mid
->when_received
= jiffies
;
637 spin_lock(&GlobalMid_Lock
);
639 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
641 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
642 list_del_init(&mid
->qhead
);
643 spin_unlock(&GlobalMid_Lock
);
647 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
648 char *buf
, int malformed
)
650 if (server
->ops
->check_trans2
&&
651 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
654 mid
->large_buf
= server
->large_buf
;
655 /* Was previous buf put in mpx struct for multi-rsp? */
656 if (!mid
->multiRsp
) {
657 /* smb buffer will be freed by user thread */
658 if (server
->large_buf
)
659 server
->bigbuf
= NULL
;
661 server
->smallbuf
= NULL
;
663 dequeue_mid(mid
, malformed
);
666 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
670 /* take it off the list, if it's not already */
671 spin_lock(&cifs_tcp_ses_lock
);
672 list_del_init(&server
->tcp_ses_list
);
673 spin_unlock(&cifs_tcp_ses_lock
);
675 spin_lock(&GlobalMid_Lock
);
676 server
->tcpStatus
= CifsExiting
;
677 spin_unlock(&GlobalMid_Lock
);
678 wake_up_all(&server
->response_q
);
680 /* check if we have blocked requests that need to free */
681 spin_lock(&server
->req_lock
);
682 if (server
->credits
<= 0)
684 spin_unlock(&server
->req_lock
);
686 * Although there should not be any requests blocked on this queue it
687 * can not hurt to be paranoid and try to wake up requests that may
688 * haven been blocked when more than 50 at time were on the wire to the
689 * same server - they now will see the session is in exit state and get
690 * out of SendReceive.
692 wake_up_all(&server
->request_q
);
693 /* give those requests time to exit */
696 if (server
->ssocket
) {
697 sock_release(server
->ssocket
);
698 server
->ssocket
= NULL
;
701 if (!list_empty(&server
->pending_mid_q
)) {
702 struct list_head dispose_list
;
703 struct mid_q_entry
*mid_entry
;
704 struct list_head
*tmp
, *tmp2
;
706 INIT_LIST_HEAD(&dispose_list
);
707 spin_lock(&GlobalMid_Lock
);
708 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
709 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
710 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
711 mid_entry
->mid_state
= MID_SHUTDOWN
;
712 list_move(&mid_entry
->qhead
, &dispose_list
);
714 spin_unlock(&GlobalMid_Lock
);
716 /* now walk dispose list and issue callbacks */
717 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
718 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
719 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
720 list_del_init(&mid_entry
->qhead
);
721 mid_entry
->callback(mid_entry
);
723 /* 1/8th of sec is more than enough time for them to exit */
727 if (!list_empty(&server
->pending_mid_q
)) {
729 * mpx threads have not exited yet give them at least the smb
730 * send timeout time for long ops.
732 * Due to delays on oplock break requests, we need to wait at
733 * least 45 seconds before giving up on a request getting a
734 * response and going ahead and killing cifsd.
736 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
739 * If threads still have not exited they are probably never
740 * coming home not much else we can do but free the memory.
744 kfree(server
->hostname
);
747 length
= atomic_dec_return(&tcpSesAllocCount
);
749 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
753 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
756 char *buf
= server
->smallbuf
;
757 unsigned int pdu_length
= get_rfc1002_length(buf
);
759 /* make sure this will fit in a large buffer */
760 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) - 4) {
761 cifs_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
762 cifs_reconnect(server
);
763 wake_up(&server
->response_q
);
764 return -ECONNABORTED
;
767 /* switch to large buffer if too big for a small one */
768 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
769 server
->large_buf
= true;
770 memcpy(server
->bigbuf
, buf
, server
->total_read
);
771 buf
= server
->bigbuf
;
774 /* now read the rest */
775 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
776 pdu_length
- HEADER_SIZE(server
) + 1 + 4);
779 server
->total_read
+= length
;
781 dump_smb(buf
, server
->total_read
);
784 * We know that we received enough to get to the MID as we
785 * checked the pdu_length earlier. Now check to see
786 * if the rest of the header is OK. We borrow the length
787 * var for the rest of the loop to avoid a new stack var.
789 * 48 bytes is enough to display the header and a little bit
790 * into the payload for debugging purposes.
792 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
794 cifs_dump_mem("Bad SMB: ", buf
,
795 min_t(unsigned int, server
->total_read
, 48));
797 if (server
->ops
->is_status_pending
&&
798 server
->ops
->is_status_pending(buf
, server
, length
))
804 handle_mid(mid
, server
, buf
, length
);
809 cifs_demultiplex_thread(void *p
)
812 struct TCP_Server_Info
*server
= p
;
813 unsigned int pdu_length
;
815 struct task_struct
*task_to_wake
= NULL
;
816 struct mid_q_entry
*mid_entry
;
818 current
->flags
|= PF_MEMALLOC
;
819 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
821 length
= atomic_inc_return(&tcpSesAllocCount
);
823 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
826 while (server
->tcpStatus
!= CifsExiting
) {
830 if (!allocate_buffers(server
))
833 server
->large_buf
= false;
834 buf
= server
->smallbuf
;
835 pdu_length
= 4; /* enough to get RFC1001 header */
837 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
840 server
->total_read
= length
;
843 * The right amount was read from socket - 4 bytes,
844 * so we can now interpret the length field.
846 pdu_length
= get_rfc1002_length(buf
);
848 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
849 if (!is_smb_response(server
, buf
[0]))
852 /* make sure we have enough to get to the MID */
853 if (pdu_length
< HEADER_SIZE(server
) - 1 - 4) {
854 cifs_dbg(VFS
, "SMB response too short (%u bytes)\n",
856 cifs_reconnect(server
);
857 wake_up(&server
->response_q
);
861 /* read down to the MID */
862 length
= cifs_read_from_socket(server
, buf
+ 4,
863 HEADER_SIZE(server
) - 1 - 4);
866 server
->total_read
+= length
;
868 mid_entry
= server
->ops
->find_mid(server
, buf
);
870 if (!mid_entry
|| !mid_entry
->receive
)
871 length
= standard_receive3(server
, mid_entry
);
873 length
= mid_entry
->receive(server
, mid_entry
);
878 if (server
->large_buf
)
879 buf
= server
->bigbuf
;
881 server
->lstrp
= jiffies
;
882 if (mid_entry
!= NULL
) {
883 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
884 mid_entry
->callback(mid_entry
);
885 } else if (!server
->ops
->is_oplock_break
||
886 !server
->ops
->is_oplock_break(buf
, server
)) {
887 cifs_dbg(VFS
, "No task to wake, unknown frame received! NumMids %d\n",
888 atomic_read(&midCount
));
889 cifs_dump_mem("Received Data is: ", buf
,
890 HEADER_SIZE(server
));
891 #ifdef CONFIG_CIFS_DEBUG2
892 if (server
->ops
->dump_detail
)
893 server
->ops
->dump_detail(buf
);
894 cifs_dump_mids(server
);
895 #endif /* CIFS_DEBUG2 */
898 } /* end while !EXITING */
900 /* buffer usually freed in free_mid - need to free it here on exit */
901 cifs_buf_release(server
->bigbuf
);
902 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
903 cifs_small_buf_release(server
->smallbuf
);
905 task_to_wake
= xchg(&server
->tsk
, NULL
);
906 clean_demultiplex_info(server
);
908 /* if server->tsk was NULL then wait for a signal before exiting */
910 set_current_state(TASK_INTERRUPTIBLE
);
911 while (!signal_pending(current
)) {
913 set_current_state(TASK_INTERRUPTIBLE
);
915 set_current_state(TASK_RUNNING
);
918 module_put_and_exit(0);
921 /* extract the host portion of the UNC string */
923 extract_hostname(const char *unc
)
929 /* skip double chars at beginning of string */
930 /* BB: check validity of these bytes? */
933 /* delimiter between hostname and sharename is always '\\' now */
934 delim
= strchr(src
, '\\');
936 return ERR_PTR(-EINVAL
);
939 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
941 return ERR_PTR(-ENOMEM
);
943 memcpy(dst
, src
, len
);
949 static int get_option_ul(substring_t args
[], unsigned long *option
)
954 string
= match_strdup(args
);
957 rc
= kstrtoul(string
, 0, option
);
963 static int get_option_uid(substring_t args
[], kuid_t
*result
)
969 rc
= get_option_ul(args
, &value
);
973 uid
= make_kuid(current_user_ns(), value
);
981 static int get_option_gid(substring_t args
[], kgid_t
*result
)
987 rc
= get_option_ul(args
, &value
);
991 gid
= make_kgid(current_user_ns(), value
);
999 static int cifs_parse_security_flavors(char *value
,
1000 struct smb_vol
*vol
)
1003 substring_t args
[MAX_OPT_ARGS
];
1006 * With mount options, the last one should win. Reset any existing
1007 * settings back to default.
1009 vol
->sectype
= Unspecified
;
1012 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1014 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1020 vol
->sectype
= Kerberos
;
1022 case Opt_sec_ntlmsspi
:
1025 case Opt_sec_ntlmssp
:
1026 vol
->sectype
= RawNTLMSSP
;
1032 vol
->sectype
= NTLM
;
1034 case Opt_sec_ntlmv2i
:
1037 case Opt_sec_ntlmv2
:
1038 vol
->sectype
= NTLMv2
;
1040 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1041 case Opt_sec_lanman
:
1042 vol
->sectype
= LANMAN
;
1049 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1057 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1059 substring_t args
[MAX_OPT_ARGS
];
1061 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1062 case Opt_cache_loose
:
1063 vol
->direct_io
= false;
1064 vol
->strict_io
= false;
1066 case Opt_cache_strict
:
1067 vol
->direct_io
= false;
1068 vol
->strict_io
= true;
1070 case Opt_cache_none
:
1071 vol
->direct_io
= true;
1072 vol
->strict_io
= false;
1075 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1082 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
)
1084 substring_t args
[MAX_OPT_ARGS
];
1086 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1088 vol
->ops
= &smb1_operations
;
1089 vol
->vals
= &smb1_values
;
1091 #ifdef CONFIG_CIFS_SMB2
1093 vol
->ops
= &smb20_operations
;
1094 vol
->vals
= &smb20_values
;
1097 vol
->ops
= &smb21_operations
;
1098 vol
->vals
= &smb21_values
;
1101 vol
->ops
= &smb30_operations
;
1102 vol
->vals
= &smb30_values
;
1105 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1106 vol
->vals
= &smb302_values
;
1108 #ifdef CONFIG_CIFS_SMB311
1110 vol
->ops
= &smb311_operations
;
1111 vol
->vals
= &smb311_values
;
1116 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1123 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1124 * fields with the result. Returns 0 on success and an error otherwise.
1127 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1130 const char *delims
= "/\\";
1133 /* make sure we have a valid UNC double delimiter prefix */
1134 len
= strspn(devname
, delims
);
1138 /* find delimiter between host and sharename */
1139 pos
= strpbrk(devname
+ 2, delims
);
1143 /* skip past delimiter */
1146 /* now go until next delimiter or end of string */
1147 len
= strcspn(pos
, delims
);
1149 /* move "pos" up to delimiter or NULL */
1151 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1155 convert_delimiter(vol
->UNC
, '\\');
1157 /* skip any delimiter */
1158 if (*pos
== '/' || *pos
== '\\')
1161 /* If pos is NULL then no prepath */
1165 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1173 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1174 struct smb_vol
*vol
)
1177 char *mountdata_copy
= NULL
, *options
;
1178 unsigned int temp_len
, i
, j
;
1180 short int override_uid
= -1;
1181 short int override_gid
= -1;
1182 bool uid_specified
= false;
1183 bool gid_specified
= false;
1184 bool sloppy
= false;
1185 char *invalid
= NULL
;
1186 char *nodename
= utsname()->nodename
;
1187 char *string
= NULL
;
1188 char *tmp_end
, *value
;
1190 bool got_ip
= false;
1191 unsigned short port
= 0;
1192 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1196 delim
= separator
[0];
1198 /* ensure we always start with zeroed-out smb_vol */
1199 memset(vol
, 0, sizeof(*vol
));
1202 * does not have to be perfect mapping since field is
1203 * informational, only used for servers that do not support
1204 * port 445 and it can be overridden at mount time
1206 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1207 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1208 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1210 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1211 /* null target name indicates to use *SMBSERVR default called name
1212 if we end up sending RFC1001 session initialize */
1213 vol
->target_rfc1001_name
[0] = 0;
1214 vol
->cred_uid
= current_uid();
1215 vol
->linux_uid
= current_uid();
1216 vol
->linux_gid
= current_gid();
1219 * default to SFM style remapping of seven reserved characters
1220 * unless user overrides it or we negotiate CIFS POSIX where
1221 * it is unnecessary. Can not simultaneously use more than one mapping
1222 * since then readdir could list files that open could not open
1226 /* default to only allowing write access to owner of the mount */
1227 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1229 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1230 /* default is always to request posix paths. */
1231 vol
->posix_paths
= 1;
1232 /* default to using server inode numbers where available */
1233 vol
->server_ino
= 1;
1235 /* default is to use strict cifs caching semantics */
1236 vol
->strict_io
= true;
1238 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1240 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1241 vol
->ops
= &smb1_operations
;
1242 vol
->vals
= &smb1_values
;
1244 vol
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
;
1247 goto cifs_parse_mount_err
;
1249 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1250 if (!mountdata_copy
)
1251 goto cifs_parse_mount_err
;
1253 options
= mountdata_copy
;
1254 end
= options
+ strlen(options
);
1256 if (strncmp(options
, "sep=", 4) == 0) {
1257 if (options
[4] != 0) {
1258 separator
[0] = options
[4];
1261 cifs_dbg(FYI
, "Null separator not allowed\n");
1264 vol
->backupuid_specified
= false; /* no backup intent for a user */
1265 vol
->backupgid_specified
= false; /* no backup intent for a group */
1267 switch (cifs_parse_devname(devname
, vol
)) {
1271 cifs_dbg(VFS
, "Unable to allocate memory for devname.\n");
1272 goto cifs_parse_mount_err
;
1274 cifs_dbg(VFS
, "Malformed UNC in devname.\n");
1275 goto cifs_parse_mount_err
;
1277 cifs_dbg(VFS
, "Unknown error parsing devname.\n");
1278 goto cifs_parse_mount_err
;
1281 while ((data
= strsep(&options
, separator
)) != NULL
) {
1282 substring_t args
[MAX_OPT_ARGS
];
1283 unsigned long option
;
1289 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1293 /* Ingnore the following */
1297 /* Boolean values */
1298 case Opt_user_xattr
:
1301 case Opt_nouser_xattr
:
1307 case Opt_noforceuid
:
1313 case Opt_noforcegid
:
1316 case Opt_noblocksend
:
1317 vol
->noblocksnd
= 1;
1319 case Opt_noautotune
:
1320 vol
->noautotune
= 1;
1335 vol
->sfu_remap
= true;
1336 vol
->remap
= false; /* disable SFM mapping */
1338 case Opt_nomapchars
:
1339 vol
->sfu_remap
= false;
1343 vol
->sfu_remap
= false; /* disable SFU mapping */
1345 case Opt_nomapposix
:
1357 case Opt_posixpaths
:
1358 vol
->posix_paths
= 1;
1360 case Opt_noposixpaths
:
1361 vol
->posix_paths
= 0;
1364 vol
->no_linux_ext
= 1;
1375 * turn off mandatory locking in mode
1376 * if remote locking is turned off since the
1377 * local vfs will do advisory
1379 if (vol
->file_mode
==
1380 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1381 vol
->file_mode
= S_IALLUGO
;
1383 case Opt_forcemandatorylock
:
1392 case Opt_setuidfromacl
:
1393 vol
->setuidfromacl
= 1;
1396 vol
->dynperm
= true;
1399 vol
->dynperm
= false;
1413 case Opt_nostrictsync
:
1414 vol
->nostrictsync
= 1;
1416 case Opt_strictsync
:
1417 vol
->nostrictsync
= 0;
1420 vol
->server_ino
= 1;
1422 case Opt_noserverino
:
1423 vol
->server_ino
= 0;
1425 case Opt_rwpidforward
:
1426 vol
->rwpidforward
= 1;
1435 vol
->no_psx_acl
= 0;
1438 vol
->no_psx_acl
= 1;
1440 case Opt_locallease
:
1441 vol
->local_lease
= 1;
1447 /* we do not do the following in secFlags because seal
1448 * is a per tree connection (mount) not a per socket
1449 * or per-smb connection option in the protocol
1450 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1455 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1458 #ifndef CONFIG_CIFS_FSCACHE
1459 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1460 goto cifs_parse_mount_err
;
1464 case Opt_mfsymlinks
:
1465 vol
->mfsymlinks
= true;
1468 vol
->multiuser
= true;
1473 case Opt_nosharesock
:
1474 vol
->nosharesock
= true;
1476 case Opt_nopersistent
:
1477 vol
->nopersistent
= true;
1478 if (vol
->persistent
) {
1480 "persistenthandles mount options conflict\n");
1481 goto cifs_parse_mount_err
;
1484 case Opt_persistent
:
1485 vol
->persistent
= true;
1486 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1488 "persistenthandles mount options conflict\n");
1489 goto cifs_parse_mount_err
;
1493 vol
->resilient
= true;
1494 if (vol
->persistent
) {
1496 "persistenthandles mount options conflict\n");
1497 goto cifs_parse_mount_err
;
1500 case Opt_noresilient
:
1501 vol
->resilient
= false; /* already the default */
1504 /* Numeric Values */
1506 if (get_option_uid(args
, &vol
->backupuid
)) {
1507 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
1509 goto cifs_parse_mount_err
;
1511 vol
->backupuid_specified
= true;
1514 if (get_option_gid(args
, &vol
->backupgid
)) {
1515 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
1517 goto cifs_parse_mount_err
;
1519 vol
->backupgid_specified
= true;
1522 if (get_option_uid(args
, &vol
->linux_uid
)) {
1523 cifs_dbg(VFS
, "%s: Invalid uid value\n",
1525 goto cifs_parse_mount_err
;
1527 uid_specified
= true;
1530 if (get_option_uid(args
, &vol
->cred_uid
)) {
1531 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
1533 goto cifs_parse_mount_err
;
1537 if (get_option_gid(args
, &vol
->linux_gid
)) {
1538 cifs_dbg(VFS
, "%s: Invalid gid value\n",
1540 goto cifs_parse_mount_err
;
1542 gid_specified
= true;
1545 if (get_option_ul(args
, &option
)) {
1546 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
1548 goto cifs_parse_mount_err
;
1550 vol
->file_mode
= option
;
1553 if (get_option_ul(args
, &option
)) {
1554 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
1556 goto cifs_parse_mount_err
;
1558 vol
->dir_mode
= option
;
1561 if (get_option_ul(args
, &option
) ||
1562 option
> USHRT_MAX
) {
1563 cifs_dbg(VFS
, "%s: Invalid port value\n",
1565 goto cifs_parse_mount_err
;
1567 port
= (unsigned short)option
;
1570 if (get_option_ul(args
, &option
)) {
1571 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
1573 goto cifs_parse_mount_err
;
1575 vol
->rsize
= option
;
1578 if (get_option_ul(args
, &option
)) {
1579 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
1581 goto cifs_parse_mount_err
;
1583 vol
->wsize
= option
;
1586 if (get_option_ul(args
, &option
)) {
1587 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
1589 goto cifs_parse_mount_err
;
1591 vol
->actimeo
= HZ
* option
;
1592 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1593 cifs_dbg(VFS
, "attribute cache timeout too large\n");
1594 goto cifs_parse_mount_err
;
1597 case Opt_echo_interval
:
1598 if (get_option_ul(args
, &option
)) {
1599 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
1601 goto cifs_parse_mount_err
;
1603 vol
->echo_interval
= option
;
1605 case Opt_max_credits
:
1606 if (get_option_ul(args
, &option
) || (option
< 20) ||
1608 cifs_dbg(VFS
, "%s: Invalid max_credits value\n",
1610 goto cifs_parse_mount_err
;
1612 vol
->max_credits
= option
;
1615 /* String Arguments */
1617 case Opt_blank_user
:
1618 /* null user, ie. anonymous authentication */
1620 vol
->username
= NULL
;
1623 string
= match_strdup(args
);
1627 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
1628 CIFS_MAX_USERNAME_LEN
) {
1629 pr_warn("CIFS: username too long\n");
1630 goto cifs_parse_mount_err
;
1633 kfree(vol
->username
);
1634 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1636 goto cifs_parse_mount_err
;
1638 case Opt_blank_pass
:
1639 /* passwords have to be handled differently
1640 * to allow the character used for deliminator
1641 * to be passed within them
1645 * Check if this is a case where the password
1646 * starts with a delimiter
1648 tmp_end
= strchr(data
, '=');
1650 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
1651 /* No it is not. Set the password to NULL */
1652 kfree(vol
->password
);
1653 vol
->password
= NULL
;
1656 /* Yes it is. Drop down to Opt_pass below.*/
1658 /* Obtain the value string */
1659 value
= strchr(data
, '=');
1662 /* Set tmp_end to end of the string */
1663 tmp_end
= (char *) value
+ strlen(value
);
1665 /* Check if following character is the deliminator
1666 * If yes, we have encountered a double deliminator
1667 * reset the NULL character to the deliminator
1669 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
1672 /* Keep iterating until we get to a single
1673 * deliminator OR the end
1675 while ((tmp_end
= strchr(tmp_end
, delim
))
1676 != NULL
&& (tmp_end
[1] == delim
)) {
1677 tmp_end
= (char *) &tmp_end
[2];
1680 /* Reset var options to point to next element */
1683 options
= (char *) &tmp_end
[1];
1685 /* Reached the end of the mount option
1690 kfree(vol
->password
);
1691 /* Now build new password string */
1692 temp_len
= strlen(value
);
1693 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1694 if (vol
->password
== NULL
) {
1695 pr_warn("CIFS: no memory for password\n");
1696 goto cifs_parse_mount_err
;
1699 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1700 vol
->password
[j
] = value
[i
];
1701 if ((value
[i
] == delim
) &&
1702 value
[i
+1] == delim
)
1703 /* skip the second deliminator */
1706 vol
->password
[j
] = '\0';
1709 /* FIXME: should this be an error instead? */
1713 string
= match_strdup(args
);
1717 if (!cifs_convert_address(dstaddr
, string
,
1719 pr_err("CIFS: bad ip= option (%s).\n", string
);
1720 goto cifs_parse_mount_err
;
1725 string
= match_strdup(args
);
1729 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
1730 == CIFS_MAX_DOMAINNAME_LEN
) {
1731 pr_warn("CIFS: domain name too long\n");
1732 goto cifs_parse_mount_err
;
1735 kfree(vol
->domainname
);
1736 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1737 if (!vol
->domainname
) {
1738 pr_warn("CIFS: no memory for domainname\n");
1739 goto cifs_parse_mount_err
;
1741 cifs_dbg(FYI
, "Domain name set\n");
1744 string
= match_strdup(args
);
1748 if (!cifs_convert_address(
1749 (struct sockaddr
*)&vol
->srcaddr
,
1750 string
, strlen(string
))) {
1751 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1753 goto cifs_parse_mount_err
;
1757 string
= match_strdup(args
);
1761 if (strnlen(string
, 1024) >= 65) {
1762 pr_warn("CIFS: iocharset name too long.\n");
1763 goto cifs_parse_mount_err
;
1766 if (strncasecmp(string
, "default", 7) != 0) {
1767 kfree(vol
->iocharset
);
1768 vol
->iocharset
= kstrdup(string
,
1770 if (!vol
->iocharset
) {
1771 pr_warn("CIFS: no memory for charset\n");
1772 goto cifs_parse_mount_err
;
1775 /* if iocharset not set then load_nls_default
1778 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
1780 case Opt_netbiosname
:
1781 string
= match_strdup(args
);
1785 memset(vol
->source_rfc1001_name
, 0x20,
1788 * FIXME: are there cases in which a comma can
1789 * be valid in workstation netbios name (and
1790 * need special handling)?
1792 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1793 /* don't ucase netbiosname for user */
1796 vol
->source_rfc1001_name
[i
] = string
[i
];
1798 /* The string has 16th byte zero still from
1799 * set at top of the function
1801 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1802 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1805 /* servernetbiosname specified override *SMBSERVER */
1806 string
= match_strdup(args
);
1810 /* last byte, type, is 0x20 for servr type */
1811 memset(vol
->target_rfc1001_name
, 0x20,
1812 RFC1001_NAME_LEN_WITH_NULL
);
1814 /* BB are there cases in which a comma can be
1815 valid in this workstation netbios name
1816 (and need special handling)? */
1818 /* user or mount helper must uppercase the
1820 for (i
= 0; i
< 15; i
++) {
1823 vol
->target_rfc1001_name
[i
] = string
[i
];
1825 /* The string has 16th byte zero still from
1826 set at top of the function */
1827 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1828 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1831 string
= match_strdup(args
);
1835 if (strncasecmp(string
, "1", 1) == 0) {
1836 /* This is the default */
1839 /* For all other value, error */
1840 pr_warn("CIFS: Invalid version specified\n");
1841 goto cifs_parse_mount_err
;
1843 string
= match_strdup(args
);
1847 if (cifs_parse_smb_version(string
, vol
) != 0)
1848 goto cifs_parse_mount_err
;
1851 string
= match_strdup(args
);
1855 if (cifs_parse_security_flavors(string
, vol
) != 0)
1856 goto cifs_parse_mount_err
;
1859 string
= match_strdup(args
);
1863 if (cifs_parse_cache_flavor(string
, vol
) != 0)
1864 goto cifs_parse_mount_err
;
1868 * An option we don't recognize. Save it off for later
1869 * if we haven't already found one
1875 /* Free up any allocated string */
1880 if (!sloppy
&& invalid
) {
1881 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid
);
1882 goto cifs_parse_mount_err
;
1886 /* Muliuser mounts require CONFIG_KEYS support */
1887 if (vol
->multiuser
) {
1888 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1889 goto cifs_parse_mount_err
;
1893 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
1894 goto cifs_parse_mount_err
;
1897 /* make sure UNC has a share name */
1898 if (!strchr(vol
->UNC
+ 3, '\\')) {
1899 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
1900 goto cifs_parse_mount_err
;
1904 /* No ip= option specified? Try to get it from UNC */
1905 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2],
1906 strlen(&vol
->UNC
[2]))) {
1907 pr_err("Unable to determine destination address.\n");
1908 goto cifs_parse_mount_err
;
1912 /* set the port that we got earlier */
1913 cifs_set_port(dstaddr
, port
);
1916 vol
->override_uid
= override_uid
;
1917 else if (override_uid
== 1)
1918 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1921 vol
->override_gid
= override_gid
;
1922 else if (override_gid
== 1)
1923 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1925 kfree(mountdata_copy
);
1929 pr_warn("Could not allocate temporary buffer\n");
1930 cifs_parse_mount_err
:
1932 kfree(mountdata_copy
);
1936 /** Returns true if srcaddr isn't specified and rhs isn't
1937 * specified, or if srcaddr is specified and
1938 * matches the IP address of the rhs argument.
1941 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1943 switch (srcaddr
->sa_family
) {
1945 return (rhs
->sa_family
== AF_UNSPEC
);
1947 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1948 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1949 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1952 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1953 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
1954 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1958 return false; /* don't expect to be here */
1963 * If no port is specified in addr structure, we try to match with 445 port
1964 * and if it fails - with 139 ports. It should be called only if address
1965 * families of server and addr are equal.
1968 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1970 __be16 port
, *sport
;
1972 switch (addr
->sa_family
) {
1974 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1975 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1978 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1979 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1987 port
= htons(CIFS_PORT
);
1991 port
= htons(RFC1001_PORT
);
1994 return port
== *sport
;
1998 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1999 struct sockaddr
*srcaddr
)
2001 switch (addr
->sa_family
) {
2003 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
2004 struct sockaddr_in
*srv_addr4
=
2005 (struct sockaddr_in
*)&server
->dstaddr
;
2007 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
2012 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
2013 struct sockaddr_in6
*srv_addr6
=
2014 (struct sockaddr_in6
*)&server
->dstaddr
;
2016 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
2017 &srv_addr6
->sin6_addr
))
2019 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
2025 return false; /* don't expect to be here */
2028 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2035 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2038 * The select_sectype function should either return the vol->sectype
2039 * that was specified, or "Unspecified" if that sectype was not
2040 * compatible with the given NEGOTIATE request.
2042 if (select_sectype(server
, vol
->sectype
) == Unspecified
)
2046 * Now check if signing mode is acceptable. No need to check
2047 * global_secflags at this point since if MUST_SIGN is set then
2048 * the server->sign had better be too.
2050 if (vol
->sign
&& !server
->sign
)
2056 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2058 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2060 if (vol
->nosharesock
)
2063 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2066 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2069 if (!match_address(server
, addr
,
2070 (struct sockaddr
*)&vol
->srcaddr
))
2073 if (!match_port(server
, addr
))
2076 if (!match_security(server
, vol
))
2079 if (server
->echo_interval
!= vol
->echo_interval
* HZ
)
2085 static struct TCP_Server_Info
*
2086 cifs_find_tcp_session(struct smb_vol
*vol
)
2088 struct TCP_Server_Info
*server
;
2090 spin_lock(&cifs_tcp_ses_lock
);
2091 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2092 if (!match_server(server
, vol
))
2095 ++server
->srv_count
;
2096 spin_unlock(&cifs_tcp_ses_lock
);
2097 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2100 spin_unlock(&cifs_tcp_ses_lock
);
2105 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
2107 struct task_struct
*task
;
2109 spin_lock(&cifs_tcp_ses_lock
);
2110 if (--server
->srv_count
> 0) {
2111 spin_unlock(&cifs_tcp_ses_lock
);
2115 put_net(cifs_net_ns(server
));
2117 list_del_init(&server
->tcp_ses_list
);
2118 spin_unlock(&cifs_tcp_ses_lock
);
2120 cancel_delayed_work_sync(&server
->echo
);
2122 spin_lock(&GlobalMid_Lock
);
2123 server
->tcpStatus
= CifsExiting
;
2124 spin_unlock(&GlobalMid_Lock
);
2126 cifs_crypto_shash_release(server
);
2127 cifs_fscache_release_client_cookie(server
);
2129 kfree(server
->session_key
.response
);
2130 server
->session_key
.response
= NULL
;
2131 server
->session_key
.len
= 0;
2133 task
= xchg(&server
->tsk
, NULL
);
2135 force_sig(SIGKILL
, task
);
2138 static struct TCP_Server_Info
*
2139 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2141 struct TCP_Server_Info
*tcp_ses
= NULL
;
2144 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2146 /* see if we already have a matching tcp_ses */
2147 tcp_ses
= cifs_find_tcp_session(volume_info
);
2151 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2157 tcp_ses
->ops
= volume_info
->ops
;
2158 tcp_ses
->vals
= volume_info
->vals
;
2159 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2160 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2161 if (IS_ERR(tcp_ses
->hostname
)) {
2162 rc
= PTR_ERR(tcp_ses
->hostname
);
2163 goto out_err_crypto_release
;
2166 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2167 tcp_ses
->noautotune
= volume_info
->noautotune
;
2168 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2169 tcp_ses
->in_flight
= 0;
2170 tcp_ses
->credits
= 1;
2171 init_waitqueue_head(&tcp_ses
->response_q
);
2172 init_waitqueue_head(&tcp_ses
->request_q
);
2173 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2174 mutex_init(&tcp_ses
->srv_mutex
);
2175 memcpy(tcp_ses
->workstation_RFC1001_name
,
2176 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2177 memcpy(tcp_ses
->server_RFC1001_name
,
2178 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2179 tcp_ses
->session_estab
= false;
2180 tcp_ses
->sequence_number
= 0;
2181 tcp_ses
->lstrp
= jiffies
;
2182 spin_lock_init(&tcp_ses
->req_lock
);
2183 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2184 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2185 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2186 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2187 sizeof(tcp_ses
->srcaddr
));
2188 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2189 sizeof(tcp_ses
->dstaddr
));
2190 #ifdef CONFIG_CIFS_SMB2
2191 generate_random_uuid(tcp_ses
->client_guid
);
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 ++tcp_ses
->srv_count
;
2201 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2202 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2203 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2205 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2207 rc
= ip_connect(tcp_ses
);
2209 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2210 goto out_err_crypto_release
;
2214 * since we're in a cifs function already, we know that
2215 * this will succeed. No need for try_module_get().
2217 __module_get(THIS_MODULE
);
2218 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2220 if (IS_ERR(tcp_ses
->tsk
)) {
2221 rc
= PTR_ERR(tcp_ses
->tsk
);
2222 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2223 module_put(THIS_MODULE
);
2224 goto out_err_crypto_release
;
2226 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2228 /* thread spawned, put it on the list */
2229 spin_lock(&cifs_tcp_ses_lock
);
2230 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2231 spin_unlock(&cifs_tcp_ses_lock
);
2233 cifs_fscache_get_client_cookie(tcp_ses
);
2235 /* queue echo request delayed work */
2236 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2240 out_err_crypto_release
:
2241 cifs_crypto_shash_release(tcp_ses
);
2243 put_net(cifs_net_ns(tcp_ses
));
2247 if (!IS_ERR(tcp_ses
->hostname
))
2248 kfree(tcp_ses
->hostname
);
2249 if (tcp_ses
->ssocket
)
2250 sock_release(tcp_ses
->ssocket
);
2256 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2258 if (vol
->sectype
!= Unspecified
&&
2259 vol
->sectype
!= ses
->sectype
)
2262 switch (ses
->sectype
) {
2264 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2268 /* NULL username means anonymous session */
2269 if (ses
->user_name
== NULL
) {
2275 /* anything else takes username/password */
2276 if (strncmp(ses
->user_name
,
2277 vol
->username
? vol
->username
: "",
2278 CIFS_MAX_USERNAME_LEN
))
2280 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2281 ses
->password
!= NULL
&&
2282 strncmp(ses
->password
,
2283 vol
->password
? vol
->password
: "",
2284 CIFS_MAX_PASSWORD_LEN
))
2290 static struct cifs_ses
*
2291 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2293 struct cifs_ses
*ses
;
2295 spin_lock(&cifs_tcp_ses_lock
);
2296 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2297 if (ses
->status
== CifsExiting
)
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
)
2312 unsigned int rc
, xid
;
2313 struct TCP_Server_Info
*server
= ses
->server
;
2315 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2317 spin_lock(&cifs_tcp_ses_lock
);
2318 if (ses
->status
== CifsExiting
) {
2319 spin_unlock(&cifs_tcp_ses_lock
);
2322 if (--ses
->ses_count
> 0) {
2323 spin_unlock(&cifs_tcp_ses_lock
);
2326 if (ses
->status
== CifsGood
)
2327 ses
->status
= CifsExiting
;
2328 spin_unlock(&cifs_tcp_ses_lock
);
2330 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
2332 rc
= server
->ops
->logoff(xid
, ses
);
2334 cifs_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
2339 spin_lock(&cifs_tcp_ses_lock
);
2340 list_del_init(&ses
->smb_ses_list
);
2341 spin_unlock(&cifs_tcp_ses_lock
);
2344 cifs_put_tcp_session(server
);
2349 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2350 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2352 /* Populate username and pw fields from keyring if possible */
2354 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2357 const char *delim
, *payload
;
2361 struct TCP_Server_Info
*server
= ses
->server
;
2362 struct sockaddr_in
*sa
;
2363 struct sockaddr_in6
*sa6
;
2364 const struct user_key_payload
*upayload
;
2366 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2370 /* try to find an address key first */
2371 switch (server
->dstaddr
.ss_family
) {
2373 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2374 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2377 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2378 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2381 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
2382 server
->dstaddr
.ss_family
);
2387 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2388 key
= request_key(&key_type_logon
, desc
, "");
2390 if (!ses
->domainName
) {
2391 cifs_dbg(FYI
, "domainName is NULL\n");
2396 /* didn't work, try to find a domain key */
2397 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2398 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2399 key
= request_key(&key_type_logon
, desc
, "");
2406 down_read(&key
->sem
);
2407 upayload
= user_key_payload(key
);
2408 if (IS_ERR_OR_NULL(upayload
)) {
2409 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2413 /* find first : in payload */
2414 payload
= upayload
->data
;
2415 delim
= strnchr(payload
, upayload
->datalen
, ':');
2416 cifs_dbg(FYI
, "payload=%s\n", payload
);
2418 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
2424 len
= delim
- payload
;
2425 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
2426 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
2432 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2433 if (!vol
->username
) {
2434 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
2439 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
2441 len
= key
->datalen
- (len
+ 1);
2442 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
2443 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
2445 kfree(vol
->username
);
2446 vol
->username
= NULL
;
2451 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2452 if (!vol
->password
) {
2453 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
2456 kfree(vol
->username
);
2457 vol
->username
= NULL
;
2466 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
2469 #else /* ! CONFIG_KEYS */
2471 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2472 struct cifs_ses
*ses
__attribute__((unused
)))
2476 #endif /* CONFIG_KEYS */
2478 static struct cifs_ses
*
2479 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2483 struct cifs_ses
*ses
;
2484 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2485 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2489 ses
= cifs_find_smb_ses(server
, volume_info
);
2491 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
2494 mutex_lock(&ses
->session_mutex
);
2495 rc
= cifs_negotiate_protocol(xid
, ses
);
2497 mutex_unlock(&ses
->session_mutex
);
2498 /* problem -- put our ses reference */
2499 cifs_put_smb_ses(ses
);
2503 if (ses
->need_reconnect
) {
2504 cifs_dbg(FYI
, "Session needs reconnect\n");
2505 rc
= cifs_setup_session(xid
, ses
,
2506 volume_info
->local_nls
);
2508 mutex_unlock(&ses
->session_mutex
);
2509 /* problem -- put our reference */
2510 cifs_put_smb_ses(ses
);
2515 mutex_unlock(&ses
->session_mutex
);
2517 /* existing SMB ses has a server reference already */
2518 cifs_put_tcp_session(server
);
2523 cifs_dbg(FYI
, "Existing smb sess not found\n");
2524 ses
= sesInfoAlloc();
2528 /* new SMB session uses our server ref */
2529 ses
->server
= server
;
2530 if (server
->dstaddr
.ss_family
== AF_INET6
)
2531 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2533 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2535 if (volume_info
->username
) {
2536 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2537 if (!ses
->user_name
)
2541 /* volume_info->password freed at unmount */
2542 if (volume_info
->password
) {
2543 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2547 if (volume_info
->domainname
) {
2548 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2549 if (!ses
->domainName
)
2552 ses
->cred_uid
= volume_info
->cred_uid
;
2553 ses
->linux_uid
= volume_info
->linux_uid
;
2555 ses
->sectype
= volume_info
->sectype
;
2556 ses
->sign
= volume_info
->sign
;
2558 mutex_lock(&ses
->session_mutex
);
2559 rc
= cifs_negotiate_protocol(xid
, ses
);
2561 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2562 mutex_unlock(&ses
->session_mutex
);
2566 /* success, put it on the list */
2567 spin_lock(&cifs_tcp_ses_lock
);
2568 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2569 spin_unlock(&cifs_tcp_ses_lock
);
2580 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2582 if (tcon
->tidStatus
== CifsExiting
)
2584 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2589 static struct cifs_tcon
*
2590 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2592 struct list_head
*tmp
;
2593 struct cifs_tcon
*tcon
;
2595 spin_lock(&cifs_tcp_ses_lock
);
2596 list_for_each(tmp
, &ses
->tcon_list
) {
2597 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2598 if (!match_tcon(tcon
, unc
))
2601 spin_unlock(&cifs_tcp_ses_lock
);
2604 spin_unlock(&cifs_tcp_ses_lock
);
2609 cifs_put_tcon(struct cifs_tcon
*tcon
)
2612 struct cifs_ses
*ses
= tcon
->ses
;
2614 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2615 spin_lock(&cifs_tcp_ses_lock
);
2616 if (--tcon
->tc_count
> 0) {
2617 spin_unlock(&cifs_tcp_ses_lock
);
2621 list_del_init(&tcon
->tcon_list
);
2622 spin_unlock(&cifs_tcp_ses_lock
);
2625 if (ses
->server
->ops
->tree_disconnect
)
2626 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2629 cifs_fscache_release_super_cookie(tcon
);
2631 cifs_put_smb_ses(ses
);
2634 static struct cifs_tcon
*
2635 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2638 struct cifs_tcon
*tcon
;
2640 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2642 cifs_dbg(FYI
, "Found match on UNC path\n");
2643 /* existing tcon already has a reference */
2644 cifs_put_smb_ses(ses
);
2645 if (tcon
->seal
!= volume_info
->seal
)
2646 cifs_dbg(VFS
, "transport encryption setting conflicts with existing tid\n");
2650 if (!ses
->server
->ops
->tree_connect
) {
2655 tcon
= tconInfoAlloc();
2662 if (volume_info
->password
) {
2663 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2664 if (!tcon
->password
) {
2671 * BB Do we need to wrap session_mutex around this TCon call and Unix
2672 * SetFS as we do on SessSetup and reconnect?
2675 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
2676 volume_info
->local_nls
);
2678 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
2682 if (volume_info
->nodfs
) {
2683 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2684 cifs_dbg(FYI
, "DFS disabled (%d)\n", tcon
->Flags
);
2686 tcon
->seal
= volume_info
->seal
;
2687 tcon
->use_persistent
= false;
2688 /* check if SMB2 or later, CIFS does not support persistent handles */
2689 if (volume_info
->persistent
) {
2690 if (ses
->server
->vals
->protocol_id
== 0) {
2692 "SMB3 or later required for persistent handles\n");
2695 #ifdef CONFIG_CIFS_SMB2
2696 } else if (ses
->server
->capabilities
&
2697 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2698 tcon
->use_persistent
= true;
2699 else /* persistent handles requested but not supported */ {
2701 "Persistent handles not supported on share\n");
2704 #endif /* CONFIG_CIFS_SMB2 */
2706 #ifdef CONFIG_CIFS_SMB2
2707 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
2708 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2709 && (volume_info
->nopersistent
== false)) {
2710 cifs_dbg(FYI
, "enabling persistent handles\n");
2711 tcon
->use_persistent
= true;
2712 #endif /* CONFIG_CIFS_SMB2 */
2713 } else if (volume_info
->resilient
) {
2714 if (ses
->server
->vals
->protocol_id
== 0) {
2716 "SMB2.1 or later required for resilient handles\n");
2720 tcon
->use_resilient
= true;
2724 * We can have only one retry value for a connection to a share so for
2725 * resources mounted more than once to the same server share the last
2726 * value passed in for the retry flag is used.
2728 tcon
->retry
= volume_info
->retry
;
2729 tcon
->nocase
= volume_info
->nocase
;
2730 tcon
->local_lease
= volume_info
->local_lease
;
2731 INIT_LIST_HEAD(&tcon
->pending_opens
);
2733 spin_lock(&cifs_tcp_ses_lock
);
2734 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2735 spin_unlock(&cifs_tcp_ses_lock
);
2737 cifs_fscache_get_super_cookie(tcon
);
2747 cifs_put_tlink(struct tcon_link
*tlink
)
2749 if (!tlink
|| IS_ERR(tlink
))
2752 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2753 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2754 tlink
->tl_time
= jiffies
;
2758 if (!IS_ERR(tlink_tcon(tlink
)))
2759 cifs_put_tcon(tlink_tcon(tlink
));
2764 static inline struct tcon_link
*
2765 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2767 return cifs_sb
->master_tlink
;
2771 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2773 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2774 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2776 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2779 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2780 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2784 * We want to share sb only if we don't specify an r/wsize or
2785 * specified r/wsize is greater than or equal to existing one.
2787 if (new->wsize
&& new->wsize
< old
->wsize
)
2790 if (new->rsize
&& new->rsize
< old
->rsize
)
2793 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
2796 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2797 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2800 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2803 if (old
->actimeo
!= new->actimeo
)
2810 match_prepath(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2812 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2813 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2815 if (old
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
) {
2816 if (!(new->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
))
2818 /* The prepath should be null terminated strings */
2819 if (strcmp(new->prepath
, old
->prepath
))
2828 cifs_match_super(struct super_block
*sb
, void *data
)
2830 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2831 struct smb_vol
*volume_info
;
2832 struct cifs_sb_info
*cifs_sb
;
2833 struct TCP_Server_Info
*tcp_srv
;
2834 struct cifs_ses
*ses
;
2835 struct cifs_tcon
*tcon
;
2836 struct tcon_link
*tlink
;
2839 spin_lock(&cifs_tcp_ses_lock
);
2840 cifs_sb
= CIFS_SB(sb
);
2841 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2842 if (IS_ERR(tlink
)) {
2843 spin_unlock(&cifs_tcp_ses_lock
);
2846 tcon
= tlink_tcon(tlink
);
2848 tcp_srv
= ses
->server
;
2850 volume_info
= mnt_data
->vol
;
2852 if (!match_server(tcp_srv
, volume_info
) ||
2853 !match_session(ses
, volume_info
) ||
2854 !match_tcon(tcon
, volume_info
->UNC
) ||
2855 !match_prepath(sb
, mnt_data
)) {
2860 rc
= compare_mount_options(sb
, mnt_data
);
2862 spin_unlock(&cifs_tcp_ses_lock
);
2863 cifs_put_tlink(tlink
);
2868 get_dfs_path(const unsigned int xid
, struct cifs_ses
*ses
, const char *old_path
,
2869 const struct nls_table
*nls_codepage
, unsigned int *num_referrals
,
2870 struct dfs_info3_param
**referrals
, int remap
)
2875 if (!ses
->server
->ops
->tree_connect
|| !ses
->server
->ops
->get_dfs_refer
)
2881 if (ses
->ipc_tid
== 0) {
2882 temp_unc
= kmalloc(2 /* for slashes */ +
2883 strnlen(ses
->serverName
, SERVER_NAME_LEN_WITH_NULL
* 2)
2884 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL
);
2885 if (temp_unc
== NULL
)
2889 strcpy(temp_unc
+ 2, ses
->serverName
);
2890 strcpy(temp_unc
+ 2 + strlen(ses
->serverName
), "\\IPC$");
2891 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, temp_unc
, NULL
,
2893 cifs_dbg(FYI
, "Tcon rc = %d ipc_tid = %d\n", rc
, ses
->ipc_tid
);
2897 rc
= ses
->server
->ops
->get_dfs_refer(xid
, ses
, old_path
,
2898 referrals
, num_referrals
,
2899 nls_codepage
, remap
);
2901 * BB - map targetUNCs to dfs_info3 structures, here or in
2902 * ses->server->ops->get_dfs_refer.
2908 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2909 static struct lock_class_key cifs_key
[2];
2910 static struct lock_class_key cifs_slock_key
[2];
2913 cifs_reclassify_socket4(struct socket
*sock
)
2915 struct sock
*sk
= sock
->sk
;
2916 BUG_ON(!sock_allow_reclassification(sk
));
2917 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2918 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2922 cifs_reclassify_socket6(struct socket
*sock
)
2924 struct sock
*sk
= sock
->sk
;
2925 BUG_ON(!sock_allow_reclassification(sk
));
2926 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2927 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2931 cifs_reclassify_socket4(struct socket
*sock
)
2936 cifs_reclassify_socket6(struct socket
*sock
)
2941 /* See RFC1001 section 14 on representation of Netbios names */
2942 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2946 for (i
= 0, j
= 0; i
< (length
); i
++) {
2947 /* mask a nibble at a time and encode */
2948 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2949 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2956 bind_socket(struct TCP_Server_Info
*server
)
2959 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2960 /* Bind to the specified local IP address */
2961 struct socket
*socket
= server
->ssocket
;
2962 rc
= socket
->ops
->bind(socket
,
2963 (struct sockaddr
*) &server
->srcaddr
,
2964 sizeof(server
->srcaddr
));
2966 struct sockaddr_in
*saddr4
;
2967 struct sockaddr_in6
*saddr6
;
2968 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2969 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2970 if (saddr6
->sin6_family
== AF_INET6
)
2971 cifs_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
2972 &saddr6
->sin6_addr
, rc
);
2974 cifs_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
2975 &saddr4
->sin_addr
.s_addr
, rc
);
2982 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2986 * some servers require RFC1001 sessinit before sending
2987 * negprot - BB check reconnection in case where second
2988 * sessinit is sent but no second negprot
2990 struct rfc1002_session_packet
*ses_init_buf
;
2991 struct smb_hdr
*smb_buf
;
2992 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2995 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2997 if (server
->server_RFC1001_name
[0] != 0)
2998 rfc1002mangle(ses_init_buf
->trailer
.
2999 session_req
.called_name
,
3000 server
->server_RFC1001_name
,
3001 RFC1001_NAME_LEN_WITH_NULL
);
3003 rfc1002mangle(ses_init_buf
->trailer
.
3004 session_req
.called_name
,
3005 DEFAULT_CIFS_CALLED_NAME
,
3006 RFC1001_NAME_LEN_WITH_NULL
);
3008 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
3011 * calling name ends in null (byte 16) from old smb
3014 if (server
->workstation_RFC1001_name
[0] != 0)
3015 rfc1002mangle(ses_init_buf
->trailer
.
3016 session_req
.calling_name
,
3017 server
->workstation_RFC1001_name
,
3018 RFC1001_NAME_LEN_WITH_NULL
);
3020 rfc1002mangle(ses_init_buf
->trailer
.
3021 session_req
.calling_name
,
3023 RFC1001_NAME_LEN_WITH_NULL
);
3025 ses_init_buf
->trailer
.session_req
.scope1
= 0;
3026 ses_init_buf
->trailer
.session_req
.scope2
= 0;
3027 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
3029 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3030 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
3031 rc
= smb_send(server
, smb_buf
, 0x44);
3032 kfree(ses_init_buf
);
3034 * RFC1001 layer in at least one server
3035 * requires very short break before negprot
3036 * presumably because not expecting negprot
3037 * to follow so fast. This is a simple
3038 * solution that works without
3039 * complicating the code and causes no
3040 * significant slowing down on mount
3043 usleep_range(1000, 2000);
3046 * else the negprot may still work without this
3047 * even though malloc failed
3054 generic_ip_connect(struct TCP_Server_Info
*server
)
3059 struct socket
*socket
= server
->ssocket
;
3060 struct sockaddr
*saddr
;
3062 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3064 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3065 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3066 slen
= sizeof(struct sockaddr_in6
);
3069 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3070 slen
= sizeof(struct sockaddr_in
);
3074 if (socket
== NULL
) {
3075 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3076 IPPROTO_TCP
, &socket
, 1);
3078 cifs_dbg(VFS
, "Error %d creating socket\n", rc
);
3079 server
->ssocket
= NULL
;
3083 /* BB other socket options to set KEEPALIVE, NODELAY? */
3084 cifs_dbg(FYI
, "Socket created\n");
3085 server
->ssocket
= socket
;
3086 socket
->sk
->sk_allocation
= GFP_NOFS
;
3087 if (sfamily
== AF_INET6
)
3088 cifs_reclassify_socket6(socket
);
3090 cifs_reclassify_socket4(socket
);
3093 rc
= bind_socket(server
);
3098 * Eventually check for other socket options to change from
3099 * the default. sock_setsockopt not used because it expects
3102 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3103 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3105 /* make the bufsizes depend on wsize/rsize and max requests */
3106 if (server
->noautotune
) {
3107 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3108 socket
->sk
->sk_sndbuf
= 200 * 1024;
3109 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3110 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3113 if (server
->tcp_nodelay
) {
3115 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3116 (char *)&val
, sizeof(val
));
3118 cifs_dbg(FYI
, "set TCP_NODELAY socket option error %d\n",
3122 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3123 socket
->sk
->sk_sndbuf
,
3124 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3126 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3128 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3129 sock_release(socket
);
3130 server
->ssocket
= NULL
;
3134 if (sport
== htons(RFC1001_PORT
))
3135 rc
= ip_rfc1001_connect(server
);
3141 ip_connect(struct TCP_Server_Info
*server
)
3144 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3145 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3147 if (server
->dstaddr
.ss_family
== AF_INET6
)
3148 sport
= &addr6
->sin6_port
;
3150 sport
= &addr
->sin_port
;
3155 /* try with 445 port at first */
3156 *sport
= htons(CIFS_PORT
);
3158 rc
= generic_ip_connect(server
);
3162 /* if it failed, try with 139 port */
3163 *sport
= htons(RFC1001_PORT
);
3166 return generic_ip_connect(server
);
3169 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3170 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3172 /* if we are reconnecting then should we check to see if
3173 * any requested capabilities changed locally e.g. via
3174 * remount but we can not do much about it here
3175 * if they have (even if we could detect it by the following)
3176 * Perhaps we could add a backpointer to array of sb from tcon
3177 * or if we change to make all sb to same share the same
3178 * sb as NFS - then we only have one backpointer to sb.
3179 * What if we wanted to mount the server share twice once with
3180 * and once without posixacls or posix paths? */
3181 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3183 if (vol_info
&& vol_info
->no_linux_ext
) {
3184 tcon
->fsUnixInfo
.Capability
= 0;
3185 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3186 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
3188 } else if (vol_info
)
3189 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3191 if (tcon
->unix_ext
== 0) {
3192 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
3196 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3197 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3198 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
3199 /* check for reconnect case in which we do not
3200 want to change the mount behavior if we can avoid it */
3201 if (vol_info
== NULL
) {
3202 /* turn off POSIX ACL and PATHNAMES if not set
3203 originally at mount time */
3204 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3205 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3206 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3207 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3208 cifs_dbg(VFS
, "POSIXPATH support change\n");
3209 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3210 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3211 cifs_dbg(VFS
, "possible reconnect error\n");
3212 cifs_dbg(VFS
, "server disabled POSIX path support\n");
3216 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3217 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
3219 cap
&= CIFS_UNIX_CAP_MASK
;
3220 if (vol_info
&& vol_info
->no_psx_acl
)
3221 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3222 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3223 cifs_dbg(FYI
, "negotiated posix acl support\n");
3225 cifs_sb
->mnt_cifs_flags
|=
3226 CIFS_MOUNT_POSIXACL
;
3229 if (vol_info
&& vol_info
->posix_paths
== 0)
3230 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3231 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3232 cifs_dbg(FYI
, "negotiate posix pathnames\n");
3234 cifs_sb
->mnt_cifs_flags
|=
3235 CIFS_MOUNT_POSIX_PATHS
;
3238 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
3239 #ifdef CONFIG_CIFS_DEBUG2
3240 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3241 cifs_dbg(FYI
, "FCNTL cap\n");
3242 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3243 cifs_dbg(FYI
, "EXTATTR cap\n");
3244 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3245 cifs_dbg(FYI
, "POSIX path cap\n");
3246 if (cap
& CIFS_UNIX_XATTR_CAP
)
3247 cifs_dbg(FYI
, "XATTR cap\n");
3248 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3249 cifs_dbg(FYI
, "POSIX ACL cap\n");
3250 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3251 cifs_dbg(FYI
, "very large read cap\n");
3252 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3253 cifs_dbg(FYI
, "very large write cap\n");
3254 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3255 cifs_dbg(FYI
, "transport encryption cap\n");
3256 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3257 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
3258 #endif /* CIFS_DEBUG2 */
3259 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3260 if (vol_info
== NULL
) {
3261 cifs_dbg(FYI
, "resetting capabilities failed\n");
3263 cifs_dbg(VFS
, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
3269 int cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3270 struct cifs_sb_info
*cifs_sb
)
3272 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3274 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3275 cifs_sb
->tlink_tree
= RB_ROOT
;
3278 * Temporarily set r/wsize for matching superblock. If we end up using
3279 * new sb then client will later negotiate it downward if needed.
3281 cifs_sb
->rsize
= pvolume_info
->rsize
;
3282 cifs_sb
->wsize
= pvolume_info
->wsize
;
3284 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3285 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3286 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3287 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3288 cifs_dbg(FYI
, "file mode: 0x%hx dir mode: 0x%hx\n",
3289 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3291 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3292 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3294 if (pvolume_info
->noperm
)
3295 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3296 if (pvolume_info
->setuids
)
3297 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3298 if (pvolume_info
->setuidfromacl
)
3299 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UID_FROM_ACL
;
3300 if (pvolume_info
->server_ino
)
3301 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3302 if (pvolume_info
->remap
)
3303 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
3304 if (pvolume_info
->sfu_remap
)
3305 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3306 if (pvolume_info
->no_xattr
)
3307 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3308 if (pvolume_info
->sfu_emul
)
3309 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3310 if (pvolume_info
->nobrl
)
3311 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3312 if (pvolume_info
->nostrictsync
)
3313 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3314 if (pvolume_info
->mand_lock
)
3315 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3316 if (pvolume_info
->rwpidforward
)
3317 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3318 if (pvolume_info
->cifs_acl
)
3319 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3320 if (pvolume_info
->backupuid_specified
) {
3321 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3322 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3324 if (pvolume_info
->backupgid_specified
) {
3325 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3326 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3328 if (pvolume_info
->override_uid
)
3329 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3330 if (pvolume_info
->override_gid
)
3331 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3332 if (pvolume_info
->dynperm
)
3333 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3334 if (pvolume_info
->fsc
)
3335 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3336 if (pvolume_info
->multiuser
)
3337 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3338 CIFS_MOUNT_NO_PERM
);
3339 if (pvolume_info
->strict_io
)
3340 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3341 if (pvolume_info
->direct_io
) {
3342 cifs_dbg(FYI
, "mounting share using direct i/o\n");
3343 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3345 if (pvolume_info
->mfsymlinks
) {
3346 if (pvolume_info
->sfu_emul
) {
3348 * Our SFU ("Services for Unix" emulation does not allow
3349 * creating symlinks but does allow reading existing SFU
3350 * symlinks (it does allow both creating and reading SFU
3351 * style mknod and FIFOs though). When "mfsymlinks" and
3352 * "sfu" are both enabled at the same time, it allows
3353 * reading both types of symlinks, but will only create
3354 * them with mfsymlinks format. This allows better
3355 * Apple compatibility (probably better for Samba too)
3356 * while still recognizing old Windows style symlinks.
3358 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
3360 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3363 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3364 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
3366 if (pvolume_info
->prepath
) {
3367 cifs_sb
->prepath
= kstrdup(pvolume_info
->prepath
, GFP_KERNEL
);
3368 if (cifs_sb
->prepath
== NULL
)
3376 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3378 kfree(volume_info
->username
);
3379 kzfree(volume_info
->password
);
3380 kfree(volume_info
->UNC
);
3381 kfree(volume_info
->domainname
);
3382 kfree(volume_info
->iocharset
);
3383 kfree(volume_info
->prepath
);
3387 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3391 cleanup_volume_info_contents(volume_info
);
3396 #ifdef CONFIG_CIFS_DFS_UPCALL
3398 * cifs_build_path_to_root returns full path to root when we do not have an
3399 * exiting connection (tcon)
3402 build_unc_path_to_root(const struct smb_vol
*vol
,
3403 const struct cifs_sb_info
*cifs_sb
)
3405 char *full_path
, *pos
;
3406 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
3407 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3409 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3410 if (full_path
== NULL
)
3411 return ERR_PTR(-ENOMEM
);
3413 strncpy(full_path
, vol
->UNC
, unc_len
);
3414 pos
= full_path
+ unc_len
;
3417 *pos
= CIFS_DIR_SEP(cifs_sb
);
3418 strncpy(pos
+ 1, vol
->prepath
, pplen
);
3422 *pos
= '\0'; /* add trailing null */
3423 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3424 cifs_dbg(FYI
, "%s: full_path=%s\n", __func__
, full_path
);
3429 * Perform a dfs referral query for a share and (optionally) prefix
3431 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3432 * to a string containing updated options for the submount. Otherwise it
3433 * will be left untouched.
3435 * Returns the rc from get_dfs_path to the caller, which can be used to
3436 * determine whether there were referrals.
3439 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
3440 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3444 unsigned int num_referrals
= 0;
3445 struct dfs_info3_param
*referrals
= NULL
;
3446 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3448 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3449 if (IS_ERR(full_path
))
3450 return PTR_ERR(full_path
);
3452 /* For DFS paths, skip the first '\' of the UNC */
3453 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3455 rc
= get_dfs_path(xid
, ses
, ref_path
, cifs_sb
->local_nls
,
3456 &num_referrals
, &referrals
, cifs_remap(cifs_sb
));
3458 if (!rc
&& num_referrals
> 0) {
3459 char *fake_devname
= NULL
;
3461 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3462 full_path
+ 1, referrals
,
3465 free_dfs_info_array(referrals
, num_referrals
);
3467 if (IS_ERR(mdata
)) {
3468 rc
= PTR_ERR(mdata
);
3471 cleanup_volume_info_contents(volume_info
);
3472 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3475 kfree(fake_devname
);
3476 kfree(cifs_sb
->mountdata
);
3477 cifs_sb
->mountdata
= mdata
;
3485 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3486 const char *devname
)
3490 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3493 if (volume_info
->nullauth
) {
3494 cifs_dbg(FYI
, "Anonymous login\n");
3495 kfree(volume_info
->username
);
3496 volume_info
->username
= NULL
;
3497 } else if (volume_info
->username
) {
3498 /* BB fixme parse for domain name here */
3499 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
3501 cifs_dbg(VFS
, "No username specified\n");
3502 /* In userspace mount helper we can get user name from alternate
3503 locations such as env variables and files on disk */
3507 /* this is needed for ASCII cp to Unicode converts */
3508 if (volume_info
->iocharset
== NULL
) {
3509 /* load_nls_default cannot return null */
3510 volume_info
->local_nls
= load_nls_default();
3512 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3513 if (volume_info
->local_nls
== NULL
) {
3514 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
3515 volume_info
->iocharset
);
3524 cifs_get_volume_info(char *mount_data
, const char *devname
)
3527 struct smb_vol
*volume_info
;
3529 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3531 return ERR_PTR(-ENOMEM
);
3533 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3535 cifs_cleanup_volume_info(volume_info
);
3536 volume_info
= ERR_PTR(rc
);
3543 cifs_are_all_path_components_accessible(struct TCP_Server_Info
*server
,
3545 struct cifs_tcon
*tcon
,
3546 struct cifs_sb_info
*cifs_sb
,
3553 sep
= CIFS_DIR_SEP(cifs_sb
);
3556 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, "");
3558 /* skip separators */
3563 /* next separator */
3564 while (*s
&& *s
!= sep
)
3568 * temporarily null-terminate the path at the end of
3569 * the current component
3573 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3581 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3585 struct cifs_ses
*ses
;
3586 struct cifs_tcon
*tcon
;
3587 struct TCP_Server_Info
*server
;
3589 struct tcon_link
*tlink
;
3590 #ifdef CONFIG_CIFS_DFS_UPCALL
3591 int referral_walks_count
= 0;
3594 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs");
3598 #ifdef CONFIG_CIFS_DFS_UPCALL
3600 /* cleanup activities if we're chasing a referral */
3601 if (referral_walks_count
) {
3603 cifs_put_tcon(tcon
);
3605 cifs_put_smb_ses(ses
);
3607 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
3621 /* get a reference to a tcp session */
3622 server
= cifs_get_tcp_session(volume_info
);
3623 if (IS_ERR(server
)) {
3624 rc
= PTR_ERR(server
);
3625 bdi_destroy(&cifs_sb
->bdi
);
3628 if ((volume_info
->max_credits
< 20) ||
3629 (volume_info
->max_credits
> 60000))
3630 server
->max_credits
= SMB2_MAX_CREDITS_AVAILABLE
;
3632 server
->max_credits
= volume_info
->max_credits
;
3633 /* get a reference to a SMB session */
3634 ses
= cifs_get_smb_ses(server
, volume_info
);
3638 goto mount_fail_check
;
3641 #ifdef CONFIG_CIFS_SMB2
3642 if ((volume_info
->persistent
== true) && ((ses
->server
->capabilities
&
3643 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
) == 0)) {
3644 cifs_dbg(VFS
, "persistent handles not supported by server\n");
3646 goto mount_fail_check
;
3648 #endif /* CONFIG_CIFS_SMB2*/
3650 /* search for existing tcon to this server share */
3651 tcon
= cifs_get_tcon(ses
, volume_info
);
3655 goto remote_path_check
;
3658 /* tell server which Unix caps we support */
3659 if (cap_unix(tcon
->ses
)) {
3660 /* reset of caps checks mount to see if unix extensions
3661 disabled for just this mount */
3662 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3663 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3664 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3665 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3667 goto mount_fail_check
;
3670 tcon
->unix_ext
= 0; /* server does not support them */
3672 /* do not care if a following call succeed - informational */
3673 if (!tcon
->ipc
&& server
->ops
->qfs_tcon
)
3674 server
->ops
->qfs_tcon(xid
, tcon
);
3676 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, volume_info
);
3677 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, volume_info
);
3679 /* tune readahead according to rsize */
3680 cifs_sb
->bdi
.ra_pages
= cifs_sb
->rsize
/ PAGE_SIZE
;
3683 #ifdef CONFIG_CIFS_DFS_UPCALL
3685 * Perform an unconditional check for whether there are DFS
3686 * referrals for this path without prefix, to provide support
3687 * for DFS referrals from w2k8 servers which don't seem to respond
3688 * with PATH_NOT_COVERED to requests that include the prefix.
3689 * Chase the referral if found, otherwise continue normally.
3691 if (referral_walks_count
== 0) {
3692 int refrc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
,
3695 referral_walks_count
++;
3696 goto try_mount_again
;
3701 /* check if a whole path is not remote */
3703 if (!server
->ops
->is_path_accessible
) {
3705 goto mount_fail_check
;
3708 * cifs_build_path_to_root works only when we have a valid tcon
3710 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3711 if (full_path
== NULL
) {
3713 goto mount_fail_check
;
3715 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3717 if (rc
!= 0 && rc
!= -EREMOTE
) {
3719 goto mount_fail_check
;
3722 if (rc
!= -EREMOTE
) {
3723 rc
= cifs_are_all_path_components_accessible(server
,
3727 cifs_dbg(VFS
, "cannot query dirs between root and final path, "
3728 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3729 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
3736 /* get referral if needed */
3737 if (rc
== -EREMOTE
) {
3738 #ifdef CONFIG_CIFS_DFS_UPCALL
3739 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3741 * BB: when we implement proper loop detection,
3742 * we will remove this check. But now we need it
3743 * to prevent an indefinite loop if 'DFS tree' is
3744 * misconfigured (i.e. has loops).
3747 goto mount_fail_check
;
3750 rc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
, true);
3753 referral_walks_count
++;
3754 goto try_mount_again
;
3756 goto mount_fail_check
;
3757 #else /* No DFS support, return error on mount */
3763 goto mount_fail_check
;
3765 /* now, hang the tcon off of the superblock */
3766 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3767 if (tlink
== NULL
) {
3769 goto mount_fail_check
;
3772 tlink
->tl_uid
= ses
->linux_uid
;
3773 tlink
->tl_tcon
= tcon
;
3774 tlink
->tl_time
= jiffies
;
3775 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3776 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3778 cifs_sb
->master_tlink
= tlink
;
3779 spin_lock(&cifs_sb
->tlink_tree_lock
);
3780 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3781 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3783 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3787 /* on error free sesinfo and tcon struct if needed */
3789 /* If find_unc succeeded then rc == 0 so we can not end */
3790 /* up accidentally freeing someone elses tcon struct */
3792 cifs_put_tcon(tcon
);
3794 cifs_put_smb_ses(ses
);
3796 cifs_put_tcp_session(server
);
3797 bdi_destroy(&cifs_sb
->bdi
);
3806 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3807 * pointer may be NULL.
3810 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
3811 const char *tree
, struct cifs_tcon
*tcon
,
3812 const struct nls_table
*nls_codepage
)
3814 struct smb_hdr
*smb_buffer
;
3815 struct smb_hdr
*smb_buffer_response
;
3818 unsigned char *bcc_ptr
;
3821 __u16 bytes_left
, count
;
3826 smb_buffer
= cifs_buf_get();
3827 if (smb_buffer
== NULL
)
3830 smb_buffer_response
= smb_buffer
;
3832 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3833 NULL
/*no tid */ , 4 /*wct */ );
3835 smb_buffer
->Mid
= get_next_mid(ses
->server
);
3836 smb_buffer
->Uid
= ses
->Suid
;
3837 pSMB
= (TCONX_REQ
*) smb_buffer
;
3838 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3840 pSMB
->AndXCommand
= 0xFF;
3841 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3842 bcc_ptr
= &pSMB
->Password
[0];
3843 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3844 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3845 *bcc_ptr
= 0; /* password is null byte */
3846 bcc_ptr
++; /* skip password */
3847 /* already aligned so no need to do it below */
3849 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3850 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3851 specified as required (when that support is added to
3852 the vfs in the future) as only NTLM or the much
3853 weaker LANMAN (which we do not send by default) is accepted
3854 by Samba (not sure whether other servers allow
3855 NTLMv2 password here) */
3856 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3857 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3858 (ses
->sectype
== LANMAN
))
3859 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3860 ses
->server
->sec_mode
&
3861 SECMODE_PW_ENCRYPT
? true : false,
3864 #endif /* CIFS_WEAK_PW_HASH */
3865 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3866 bcc_ptr
, nls_codepage
);
3868 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
3870 cifs_buf_release(smb_buffer
);
3874 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3875 if (ses
->capabilities
& CAP_UNICODE
) {
3876 /* must align unicode strings */
3877 *bcc_ptr
= 0; /* null byte password */
3882 if (ses
->server
->sign
)
3883 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3885 if (ses
->capabilities
& CAP_STATUS32
) {
3886 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3888 if (ses
->capabilities
& CAP_DFS
) {
3889 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3891 if (ses
->capabilities
& CAP_UNICODE
) {
3892 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3894 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
3895 6 /* max utf8 char length in bytes */ *
3896 (/* server len*/ + 256 /* share len */), nls_codepage
);
3897 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3898 bcc_ptr
+= 2; /* skip trailing null */
3899 } else { /* ASCII */
3900 strcpy(bcc_ptr
, tree
);
3901 bcc_ptr
+= strlen(tree
) + 1;
3903 strcpy(bcc_ptr
, "?????");
3904 bcc_ptr
+= strlen("?????");
3906 count
= bcc_ptr
- &pSMB
->Password
[0];
3907 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3908 pSMB
->hdr
.smb_buf_length
) + count
);
3909 pSMB
->ByteCount
= cpu_to_le16(count
);
3911 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3914 /* above now done in SendReceive */
3915 if ((rc
== 0) && (tcon
!= NULL
)) {
3918 tcon
->tidStatus
= CifsGood
;
3919 tcon
->need_reconnect
= false;
3920 tcon
->tid
= smb_buffer_response
->Tid
;
3921 bcc_ptr
= pByteArea(smb_buffer_response
);
3922 bytes_left
= get_bcc(smb_buffer_response
);
3923 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3924 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3930 /* skip service field (NB: this field is always ASCII) */
3932 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3933 (bcc_ptr
[2] == 'C')) {
3934 cifs_dbg(FYI
, "IPC connection\n");
3937 } else if (length
== 2) {
3938 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3939 /* the most common case */
3940 cifs_dbg(FYI
, "disk share connection\n");
3943 bcc_ptr
+= length
+ 1;
3944 bytes_left
-= (length
+ 1);
3945 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
3947 /* mostly informational -- no need to fail on error here */
3948 kfree(tcon
->nativeFileSystem
);
3949 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
3950 bytes_left
, is_unicode
,
3953 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
3955 if ((smb_buffer_response
->WordCount
== 3) ||
3956 (smb_buffer_response
->WordCount
== 7))
3957 /* field is in same location */
3958 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3961 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
3962 } else if ((rc
== 0) && tcon
== NULL
) {
3963 /* all we need to save for IPC$ connection */
3964 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3967 cifs_buf_release(smb_buffer
);
3971 static void delayed_free(struct rcu_head
*p
)
3973 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
3974 unload_nls(sbi
->local_nls
);
3979 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3981 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3982 struct rb_node
*node
;
3983 struct tcon_link
*tlink
;
3985 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3987 spin_lock(&cifs_sb
->tlink_tree_lock
);
3988 while ((node
= rb_first(root
))) {
3989 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3990 cifs_get_tlink(tlink
);
3991 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3992 rb_erase(node
, root
);
3994 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3995 cifs_put_tlink(tlink
);
3996 spin_lock(&cifs_sb
->tlink_tree_lock
);
3998 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4000 bdi_destroy(&cifs_sb
->bdi
);
4001 kfree(cifs_sb
->mountdata
);
4002 kfree(cifs_sb
->prepath
);
4003 call_rcu(&cifs_sb
->rcu
, delayed_free
);
4007 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
4010 struct TCP_Server_Info
*server
= ses
->server
;
4012 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
4015 /* only send once per connect */
4016 if (!server
->ops
->need_neg(server
))
4019 set_credits(server
, 1);
4021 rc
= server
->ops
->negotiate(xid
, ses
);
4023 spin_lock(&GlobalMid_Lock
);
4024 if (server
->tcpStatus
== CifsNeedNegotiate
)
4025 server
->tcpStatus
= CifsGood
;
4028 spin_unlock(&GlobalMid_Lock
);
4035 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
4036 struct nls_table
*nls_info
)
4039 struct TCP_Server_Info
*server
= ses
->server
;
4041 ses
->capabilities
= server
->capabilities
;
4042 if (linuxExtEnabled
== 0)
4043 ses
->capabilities
&= (~server
->vals
->cap_unix
);
4045 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4046 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
4048 if (server
->ops
->sess_setup
)
4049 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
4052 cifs_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
4058 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
4060 vol
->sectype
= ses
->sectype
;
4062 /* krb5 is special, since we don't need username or pw */
4063 if (vol
->sectype
== Kerberos
)
4066 return cifs_set_cifscreds(vol
, ses
);
4069 static struct cifs_tcon
*
4070 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
4073 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
4074 struct cifs_ses
*ses
;
4075 struct cifs_tcon
*tcon
= NULL
;
4076 struct smb_vol
*vol_info
;
4078 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
4079 if (vol_info
== NULL
)
4080 return ERR_PTR(-ENOMEM
);
4082 vol_info
->local_nls
= cifs_sb
->local_nls
;
4083 vol_info
->linux_uid
= fsuid
;
4084 vol_info
->cred_uid
= fsuid
;
4085 vol_info
->UNC
= master_tcon
->treeName
;
4086 vol_info
->retry
= master_tcon
->retry
;
4087 vol_info
->nocase
= master_tcon
->nocase
;
4088 vol_info
->local_lease
= master_tcon
->local_lease
;
4089 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
4090 vol_info
->sectype
= master_tcon
->ses
->sectype
;
4091 vol_info
->sign
= master_tcon
->ses
->sign
;
4093 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
4099 /* get a reference for the same TCP session */
4100 spin_lock(&cifs_tcp_ses_lock
);
4101 ++master_tcon
->ses
->server
->srv_count
;
4102 spin_unlock(&cifs_tcp_ses_lock
);
4104 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
4106 tcon
= (struct cifs_tcon
*)ses
;
4107 cifs_put_tcp_session(master_tcon
->ses
->server
);
4111 tcon
= cifs_get_tcon(ses
, vol_info
);
4113 cifs_put_smb_ses(ses
);
4118 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
4120 kfree(vol_info
->username
);
4121 kfree(vol_info
->password
);
4128 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
4130 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
4133 /* find and return a tlink with given uid */
4134 static struct tcon_link
*
4135 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
4137 struct rb_node
*node
= root
->rb_node
;
4138 struct tcon_link
*tlink
;
4141 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4143 if (uid_gt(tlink
->tl_uid
, uid
))
4144 node
= node
->rb_left
;
4145 else if (uid_lt(tlink
->tl_uid
, uid
))
4146 node
= node
->rb_right
;
4153 /* insert a tcon_link into the tree */
4155 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
4157 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
4158 struct tcon_link
*tlink
;
4161 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4164 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
4165 new = &((*new)->rb_left
);
4167 new = &((*new)->rb_right
);
4170 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4171 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4175 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4178 * If the superblock doesn't refer to a multiuser mount, then just return
4179 * the master tcon for the mount.
4181 * First, search the rbtree for an existing tcon for this fsuid. If one
4182 * exists, then check to see if it's pending construction. If it is then wait
4183 * for construction to complete. Once it's no longer pending, check to see if
4184 * it failed and either return an error or retry construction, depending on
4187 * If one doesn't exist then insert a new tcon_link struct into the tree and
4188 * try to construct a new one.
4191 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4194 kuid_t fsuid
= current_fsuid();
4195 struct tcon_link
*tlink
, *newtlink
;
4197 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4198 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4200 spin_lock(&cifs_sb
->tlink_tree_lock
);
4201 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4203 cifs_get_tlink(tlink
);
4204 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4206 if (tlink
== NULL
) {
4207 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4208 if (newtlink
== NULL
)
4209 return ERR_PTR(-ENOMEM
);
4210 newtlink
->tl_uid
= fsuid
;
4211 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4212 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4213 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4214 cifs_get_tlink(newtlink
);
4216 spin_lock(&cifs_sb
->tlink_tree_lock
);
4217 /* was one inserted after previous search? */
4218 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4220 cifs_get_tlink(tlink
);
4221 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4223 goto wait_for_construction
;
4226 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4227 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4229 wait_for_construction
:
4230 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4231 TASK_INTERRUPTIBLE
);
4233 cifs_put_tlink(tlink
);
4234 return ERR_PTR(-ERESTARTSYS
);
4237 /* if it's good, return it */
4238 if (!IS_ERR(tlink
->tl_tcon
))
4241 /* return error if we tried this already recently */
4242 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4243 cifs_put_tlink(tlink
);
4244 return ERR_PTR(-EACCES
);
4247 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4248 goto wait_for_construction
;
4251 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4252 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4253 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4255 if (IS_ERR(tlink
->tl_tcon
)) {
4256 cifs_put_tlink(tlink
);
4257 return ERR_PTR(-EACCES
);
4264 * periodic workqueue job that scans tcon_tree for a superblock and closes
4268 cifs_prune_tlinks(struct work_struct
*work
)
4270 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4272 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4273 struct rb_node
*node
= rb_first(root
);
4274 struct rb_node
*tmp
;
4275 struct tcon_link
*tlink
;
4278 * Because we drop the spinlock in the loop in order to put the tlink
4279 * it's not guarded against removal of links from the tree. The only
4280 * places that remove entries from the tree are this function and
4281 * umounts. Because this function is non-reentrant and is canceled
4282 * before umount can proceed, this is safe.
4284 spin_lock(&cifs_sb
->tlink_tree_lock
);
4285 node
= rb_first(root
);
4286 while (node
!= NULL
) {
4288 node
= rb_next(tmp
);
4289 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4291 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4292 atomic_read(&tlink
->tl_count
) != 0 ||
4293 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4296 cifs_get_tlink(tlink
);
4297 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4298 rb_erase(tmp
, root
);
4300 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4301 cifs_put_tlink(tlink
);
4302 spin_lock(&cifs_sb
->tlink_tree_lock
);
4304 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4306 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,