]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - fs/cifs/connect.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cifs: release auth_key.response for reconnect.
[mirror_ubuntu-artful-kernel.git] / fs / cifs / connect.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/connect.c
3 *
1080ef75 4 * Copyright (C) International Business Machines Corp., 2002,2011
1da177e4
LT		 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
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.
11 *
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.
16 *
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
fb8c4b14 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1da177e4
LT		 20 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
3f07c014 24#include <linux/sched/signal.h>
1da177e4
LT		 25#include <linux/list.h>
26#include <linux/wait.h>
5a0e3ad6 27#include <linux/slab.h>
1da177e4
LT		 28#include <linux/pagemap.h>
29#include <linux/ctype.h>
30#include <linux/utsname.h>
31#include <linux/mempool.h>
b8643e1b 32#include <linux/delay.h>
f191401f 33#include <linux/completion.h>
aaf737ad 34#include <linux/kthread.h>
0ae0efad 35#include <linux/pagevec.h>
7dfb7103 36#include <linux/freezer.h>
5c2503a8 37#include <linux/namei.h>
c6e970a0 38#include <linux/uuid.h>
7c0f6ba6 39#include <linux/uaccess.h>
1da177e4 40#include <asm/processor.h>
50b64e3b 41#include <linux/inet.h>
143cb494 42#include <linux/module.h>
8a8798a5 43#include <keys/user-type.h>
0e2bedaa 44#include <net/ipv6.h>
8830d7e0 45#include <linux/parser.h>
2f8b5444 46#include <linux/bvec.h>
8830d7e0 47
1da177e4
LT		 48#include "cifspdu.h"
49#include "cifsglob.h"
50#include "cifsproto.h"
51#include "cifs_unicode.h"
52#include "cifs_debug.h"
53#include "cifs_fs_sb.h"
54#include "ntlmssp.h"
55#include "nterr.h"
56#include "rfc1002pdu.h"
488f1d2d 57#include "fscache.h"
53e0e11e 58#include "smb2proto.h"
1da177e4
LT		 59
60#define CIFS_PORT 445
61#define RFC1001_PORT 139
62
1da177e4
LT		 63extern mempool_t *cifs_req_poolp;
64
2de970ff 65/* FIXME: should these be tunable? */
9d002df4 66#define TLINK_ERROR_EXPIRE (1 * HZ)
2de970ff 67#define TLINK_IDLE_EXPIRE (600 * HZ)
9d002df4 68
8830d7e0 69enum {
8830d7e0
SP		 70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
72bd481f 73 Opt_forcegid, Opt_noforcegid,
8830d7e0
SP		 74 Opt_noblocksend, Opt_noautotune,
75 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
2baa2682 76 Opt_mapposix, Opt_nomapposix,
8830d7e0
SP		 77 Opt_mapchars, Opt_nomapchars, Opt_sfu,
78 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
79 Opt_noposixpaths, Opt_nounix,
80 Opt_nocase,
81 Opt_brl, Opt_nobrl,
95932655 82 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
8830d7e0
SP		 83 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
84 Opt_nohard, Opt_nosoft,
85 Opt_nointr, Opt_intr,
86 Opt_nostrictsync, Opt_strictsync,
87 Opt_serverino, Opt_noserverino,
88 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
89 Opt_acl, Opt_noacl, Opt_locallease,
1b359204 90 Opt_sign, Opt_seal, Opt_noac,
8830d7e0 91 Opt_fsc, Opt_mfsymlinks,
a0b3df5c 92 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
b2a30774 93 Opt_persistent, Opt_nopersistent,
592fafe6 94 Opt_resilient, Opt_noresilient,
39566443 95 Opt_domainauto,
8830d7e0
SP		 96
97 /* Mount options which take numeric value */
98 Opt_backupuid, Opt_backupgid, Opt_uid,
99 Opt_cruid, Opt_gid, Opt_file_mode,
100 Opt_dirmode, Opt_port,
101 Opt_rsize, Opt_wsize, Opt_actimeo,
141891f4 102 Opt_echo_interval, Opt_max_credits,
8b217fe7 103 Opt_snapshot,
8830d7e0
SP		 104
105 /* Mount options which take string value */
106 Opt_user, Opt_pass, Opt_ip,
73a999fa 107 Opt_domain, Opt_srcaddr, Opt_iocharset,
8830d7e0 108 Opt_netbiosname, Opt_servern,
23db65f5 109 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
8830d7e0
SP		 110
111 /* Mount options to be ignored */
112 Opt_ignore,
113
114 /* Options which could be blank */
115 Opt_blank_pass,
4fe9e963
SP		 116 Opt_blank_user,
117 Opt_blank_ip,
8830d7e0
SP		 118
119 Opt_err
120};
121
122static const match_table_t cifs_mount_option_tokens = {
123
124 { Opt_user_xattr, "user_xattr" },
125 { Opt_nouser_xattr, "nouser_xattr" },
126 { Opt_forceuid, "forceuid" },
127 { Opt_noforceuid, "noforceuid" },
72bd481f
JL		 128 { Opt_forcegid, "forcegid" },
129 { Opt_noforcegid, "noforcegid" },
8830d7e0
SP		 130 { Opt_noblocksend, "noblocksend" },
131 { Opt_noautotune, "noautotune" },
132 { Opt_hard, "hard" },
133 { Opt_soft, "soft" },
134 { Opt_perm, "perm" },
135 { Opt_noperm, "noperm" },
2baa2682 136 { Opt_mapchars, "mapchars" }, /* SFU style */
8830d7e0 137 { Opt_nomapchars, "nomapchars" },
2baa2682
SF		 138 { Opt_mapposix, "mapposix" }, /* SFM style */
139 { Opt_nomapposix, "nomapposix" },
8830d7e0
SP		 140 { Opt_sfu, "sfu" },
141 { Opt_nosfu, "nosfu" },
142 { Opt_nodfs, "nodfs" },
143 { Opt_posixpaths, "posixpaths" },
144 { Opt_noposixpaths, "noposixpaths" },
145 { Opt_nounix, "nounix" },
146 { Opt_nounix, "nolinux" },
147 { Opt_nocase, "nocase" },
148 { Opt_nocase, "ignorecase" },
149 { Opt_brl, "brl" },
150 { Opt_nobrl, "nobrl" },
151 { Opt_nobrl, "nolock" },
152 { Opt_forcemandatorylock, "forcemandatorylock" },
5cfdddcf 153 { Opt_forcemandatorylock, "forcemand" },
8830d7e0
SP		 154 { Opt_setuids, "setuids" },
155 { Opt_nosetuids, "nosetuids" },
95932655 156 { Opt_setuidfromacl, "idsfromsid" },
8830d7e0
SP		 157 { Opt_dynperm, "dynperm" },
158 { Opt_nodynperm, "nodynperm" },
159 { Opt_nohard, "nohard" },
160 { Opt_nosoft, "nosoft" },
161 { Opt_nointr, "nointr" },
162 { Opt_intr, "intr" },
163 { Opt_nostrictsync, "nostrictsync" },
164 { Opt_strictsync, "strictsync" },
165 { Opt_serverino, "serverino" },
166 { Opt_noserverino, "noserverino" },
167 { Opt_rwpidforward, "rwpidforward" },
168 { Opt_cifsacl, "cifsacl" },
169 { Opt_nocifsacl, "nocifsacl" },
170 { Opt_acl, "acl" },
171 { Opt_noacl, "noacl" },
172 { Opt_locallease, "locallease" },
173 { Opt_sign, "sign" },
174 { Opt_seal, "seal" },
8830d7e0
SP		 175 { Opt_noac, "noac" },
176 { Opt_fsc, "fsc" },
177 { Opt_mfsymlinks, "mfsymlinks" },
178 { Opt_multiuser, "multiuser" },
d8162558 179 { Opt_sloppy, "sloppy" },
a0b3df5c 180 { Opt_nosharesock, "nosharesock" },
b2a30774
SF		 181 { Opt_persistent, "persistenthandles"},
182 { Opt_nopersistent, "nopersistenthandles"},
592fafe6
SF		 183 { Opt_resilient, "resilienthandles"},
184 { Opt_noresilient, "noresilienthandles"},
39566443 185 { Opt_domainauto, "domainauto"},
8830d7e0
SP		 186
187 { Opt_backupuid, "backupuid=%s" },
188 { Opt_backupgid, "backupgid=%s" },
189 { Opt_uid, "uid=%s" },
190 { Opt_cruid, "cruid=%s" },
191 { Opt_gid, "gid=%s" },
192 { Opt_file_mode, "file_mode=%s" },
193 { Opt_dirmode, "dirmode=%s" },
194 { Opt_dirmode, "dir_mode=%s" },
195 { Opt_port, "port=%s" },
196 { Opt_rsize, "rsize=%s" },
197 { Opt_wsize, "wsize=%s" },
198 { Opt_actimeo, "actimeo=%s" },
adfeb3e0 199 { Opt_echo_interval, "echo_interval=%s" },
141891f4 200 { Opt_max_credits, "max_credits=%s" },
8b217fe7 201 { Opt_snapshot, "snapshot=%s" },
8830d7e0 202
4fe9e963
SP		 203 { Opt_blank_user, "user=" },
204 { Opt_blank_user, "username=" },
8830d7e0
SP		 205 { Opt_user, "user=%s" },
206 { Opt_user, "username=%s" },
207 { Opt_blank_pass, "pass=" },
3c15b4cf 208 { Opt_blank_pass, "password=" },
8830d7e0
SP		 209 { Opt_pass, "pass=%s" },
210 { Opt_pass, "password=%s" },
4fe9e963
SP		 211 { Opt_blank_ip, "ip=" },
212 { Opt_blank_ip, "addr=" },
8830d7e0
SP		 213 { Opt_ip, "ip=%s" },
214 { Opt_ip, "addr=%s" },
73a999fa
JL		 215 { Opt_ignore, "unc=%s" },
216 { Opt_ignore, "target=%s" },
217 { Opt_ignore, "path=%s" },
8830d7e0
SP		 218 { Opt_domain, "dom=%s" },
219 { Opt_domain, "domain=%s" },
220 { Opt_domain, "workgroup=%s" },
221 { Opt_srcaddr, "srcaddr=%s" },
73a999fa 222 { Opt_ignore, "prefixpath=%s" },
8830d7e0 223 { Opt_iocharset, "iocharset=%s" },
8830d7e0
SP		 224 { Opt_netbiosname, "netbiosname=%s" },
225 { Opt_servern, "servern=%s" },
226 { Opt_ver, "ver=%s" },
23db65f5 227 { Opt_vers, "vers=%s" },
8830d7e0 228 { Opt_sec, "sec=%s" },
15b6a473 229 { Opt_cache, "cache=%s" },
8830d7e0
SP		 230
231 { Opt_ignore, "cred" },
232 { Opt_ignore, "credentials" },
a557b976
JL		 233 { Opt_ignore, "cred=%s" },
234 { Opt_ignore, "credentials=%s" },
8830d7e0
SP		 235 { Opt_ignore, "guest" },
236 { Opt_ignore, "rw" },
237 { Opt_ignore, "ro" },
238 { Opt_ignore, "suid" },
239 { Opt_ignore, "nosuid" },
240 { Opt_ignore, "exec" },
241 { Opt_ignore, "noexec" },
242 { Opt_ignore, "nodev" },
243 { Opt_ignore, "noauto" },
244 { Opt_ignore, "dev" },
245 { Opt_ignore, "mand" },
246 { Opt_ignore, "nomand" },
247 { Opt_ignore, "_netdev" },
248
249 { Opt_err, NULL }
250};
251
252enum {
253 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
254 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
7659624f
JL		 255 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
256 Opt_sec_ntlmv2i, Opt_sec_lanman,
8830d7e0
SP		 257 Opt_sec_none,
258
259 Opt_sec_err
260};
261
262static const match_table_t cifs_secflavor_tokens = {
263 { Opt_sec_krb5, "krb5" },
264 { Opt_sec_krb5i, "krb5i" },
265 { Opt_sec_krb5p, "krb5p" },
266 { Opt_sec_ntlmsspi, "ntlmsspi" },
267 { Opt_sec_ntlmssp, "ntlmssp" },
268 { Opt_ntlm, "ntlm" },
269 { Opt_sec_ntlmi, "ntlmi" },
7659624f
JL		 270 { Opt_sec_ntlmv2, "nontlm" },
271 { Opt_sec_ntlmv2, "ntlmv2" },
8830d7e0 272 { Opt_sec_ntlmv2i, "ntlmv2i" },
8830d7e0
SP		 273 { Opt_sec_lanman, "lanman" },
274 { Opt_sec_none, "none" },
275
276 { Opt_sec_err, NULL }
277};
278
15b6a473
JL		 279/* cache flavors */
280enum {
281 Opt_cache_loose,
282 Opt_cache_strict,
283 Opt_cache_none,
284 Opt_cache_err
285};
286
287static const match_table_t cifs_cacheflavor_tokens = {
288 { Opt_cache_loose, "loose" },
289 { Opt_cache_strict, "strict" },
290 { Opt_cache_none, "none" },
291 { Opt_cache_err, NULL }
292};
293
23db65f5
JL		 294static const match_table_t cifs_smb_version_tokens = {
295 { Smb_1, SMB1_VERSION_STRING },
dd446b16 296 { Smb_20, SMB20_VERSION_STRING},
1080ef75 297 { Smb_21, SMB21_VERSION_STRING },
e4aa25e7 298 { Smb_30, SMB30_VERSION_STRING },
20b6d8b4 299 { Smb_302, SMB302_VERSION_STRING },
5f7fbf73
SF		 300#ifdef CONFIG_CIFS_SMB311
301 { Smb_311, SMB311_VERSION_STRING },
aab1893d 302 { Smb_311, ALT_SMB311_VERSION_STRING },
5f7fbf73
SF		 303#endif /* SMB311 */
304 { Smb_version_err, NULL }
23db65f5
JL		 305};
306
a9f1b85e
PS		 307static int ip_connect(struct TCP_Server_Info *server);
308static int generic_ip_connect(struct TCP_Server_Info *server);
b647c35f 309static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
2de970ff 310static void cifs_prune_tlinks(struct work_struct *work);
b9bce2e9
JL		 311static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
312 const char *devname);
1da177e4 313
d5c5605c
JL		 314/*
315 * cifs tcp session reconnection
316 *
317 * mark tcp session as reconnecting so temporarily locked
318 * mark all smb sessions as reconnecting for tcp session
319 * reconnect tcp session
320 * wake up waiters on reconnection? - (not needed currently)
321 */
28ea5290 322int
1da177e4
LT		 323cifs_reconnect(struct TCP_Server_Info *server)
324{
325 int rc = 0;
f1987b44 326 struct list_head *tmp, *tmp2;
96daf2b0
SF		 327 struct cifs_ses *ses;
328 struct cifs_tcon *tcon;
fb8c4b14 329 struct mid_q_entry *mid_entry;
3c1105df 330 struct list_head retry_list;
50c2f753 331
1da177e4 332 spin_lock(&GlobalMid_Lock);
469ee614 333 if (server->tcpStatus == CifsExiting) {
fb8c4b14 334 /* the demux thread will exit normally
1da177e4
LT		 335 next time through the loop */
336 spin_unlock(&GlobalMid_Lock);
337 return rc;
338 } else
339 server->tcpStatus = CifsNeedReconnect;
340 spin_unlock(&GlobalMid_Lock);
341 server->maxBuf = 0;
aa24d1e9 342 server->max_read = 0;
1da177e4 343
f96637be 344 cifs_dbg(FYI, "Reconnecting tcp session\n");
1da177e4
LT		 345
346 /* before reconnecting the tcp session, mark the smb session (uid)
347 and the tid bad so they are not used until reconnected */
f96637be
JP		 348 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
349 __func__);
3f9bcca7 350 spin_lock(&cifs_tcp_ses_lock);
14fbf50d 351 list_for_each(tmp, &server->smb_ses_list) {
96daf2b0 352 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
14fbf50d
JL		 353 ses->need_reconnect = true;
354 ses->ipc_tid = 0;
f1987b44 355 list_for_each(tmp2, &ses->tcon_list) {
96daf2b0 356 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
3b795210 357 tcon->need_reconnect = true;
1da177e4 358 }
1da177e4 359 }
3f9bcca7 360 spin_unlock(&cifs_tcp_ses_lock);
2b84a36c 361
1da177e4 362 /* do not want to be sending data on a socket we are freeing */
f96637be 363 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
72ca545b 364 mutex_lock(&server->srv_mutex);
fb8c4b14 365 if (server->ssocket) {
f96637be
JP		 366 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
367 server->ssocket->state, server->ssocket->flags);
91cf45f0 368 kernel_sock_shutdown(server->ssocket, SHUT_WR);
f96637be
JP		 369 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
370 server->ssocket->state, server->ssocket->flags);
1da177e4
LT		 371 sock_release(server->ssocket);
372 server->ssocket = NULL;
373 }
5d0d2882
SP		 374 server->sequence_number = 0;
375 server->session_estab = false;
21e73393
SP		 376 kfree(server->session_key.response);
377 server->session_key.response = NULL;
378 server->session_key.len = 0;
fda35943 379 server->lstrp = jiffies;
1da177e4 380
2b84a36c 381 /* mark submitted MIDs for retry and issue callback */
3c1105df 382 INIT_LIST_HEAD(&retry_list);
f96637be 383 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
1da177e4 384 spin_lock(&GlobalMid_Lock);
2b84a36c
JL		 385 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
386 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
7c9421e1
PS		 387 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
388 mid_entry->mid_state = MID_RETRY_NEEDED;
3c1105df
JL		 389 list_move(&mid_entry->qhead, &retry_list);
390 }
391 spin_unlock(&GlobalMid_Lock);
820962dc 392 mutex_unlock(&server->srv_mutex);
3c1105df 393
f96637be 394 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
3c1105df
JL		 395 list_for_each_safe(tmp, tmp2, &retry_list) {
396 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
2b84a36c
JL		 397 list_del_init(&mid_entry->qhead);
398 mid_entry->callback(mid_entry);
1da177e4 399 }
1da177e4 400
7fdbaa1b 401 do {
6c3d8909 402 try_to_freeze();
a9f1b85e
PS		 403
404 /* we should try only the port we connected to before */
73e216a8 405 mutex_lock(&server->srv_mutex);
a9f1b85e 406 rc = generic_ip_connect(server);
fb8c4b14 407 if (rc) {
f96637be 408 cifs_dbg(FYI, "reconnect error %d\n", rc);
4afe260b 409 mutex_unlock(&server->srv_mutex);
0cb766ae 410 msleep(3000);
1da177e4
LT		 411 } else {
412 atomic_inc(&tcpSesReconnectCount);
413 spin_lock(&GlobalMid_Lock);
469ee614 414 if (server->tcpStatus != CifsExiting)
fd88ce93 415 server->tcpStatus = CifsNeedNegotiate;
fb8c4b14 416 spin_unlock(&GlobalMid_Lock);
4afe260b 417 mutex_unlock(&server->srv_mutex);
1da177e4 418 }
7fdbaa1b 419 } while (server->tcpStatus == CifsNeedReconnect);
2b84a36c 420
b8c60012
SP		 421 if (server->tcpStatus == CifsNeedNegotiate)
422 mod_delayed_work(cifsiod_wq, &server->echo, 0);
423
1da177e4
LT		 424 return rc;
425}
426
c74093b6
JL		 427static void
428cifs_echo_request(struct work_struct *work)
429{
430 int rc;
431 struct TCP_Server_Info *server = container_of(work,
432 struct TCP_Server_Info, echo.work);
b8c60012
SP		 433 unsigned long echo_interval;
434
435 /*
436 * If we need to renegotiate, set echo interval to zero to
437 * immediately call echo service where we can renegotiate.
438 */
439 if (server->tcpStatus == CifsNeedNegotiate)
440 echo_interval = 0;
441 else
442 echo_interval = server->echo_interval;
c74093b6 443
247ec9b4 444 /*
b8c60012
SP		 445 * We cannot send an echo if it is disabled.
446 * Also, no need to ping if we got a response recently.
247ec9b4 447 */
4fcd1813
SF		 448
449 if (server->tcpStatus == CifsNeedReconnect ||
b8c60012
SP		 450 server->tcpStatus == CifsExiting ||
451 server->tcpStatus == CifsNew ||
f6d76178 452 (server->ops->can_echo && !server->ops->can_echo(server)) ||
adfeb3e0 453 time_before(jiffies, server->lstrp + echo_interval - HZ))
c74093b6
JL		 454 goto requeue_echo;
455
f6d76178 456 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
c74093b6 457 if (rc)
f96637be
JP		 458 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
459 server->hostname);
c74093b6
JL		 460
461requeue_echo:
b8c60012 462 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
c74093b6
JL		 463}
464
3d9c2472 465static bool
2a37ef94 466allocate_buffers(struct TCP_Server_Info *server)
3d9c2472 467{
2a37ef94
JL		 468 if (!server->bigbuf) {
469 server->bigbuf = (char *)cifs_buf_get();
470 if (!server->bigbuf) {
f96637be 471 cifs_dbg(VFS, "No memory for large SMB response\n");
3d9c2472
PS		 472 msleep(3000);
473 /* retry will check if exiting */
474 return false;
475 }
2a37ef94 476 } else if (server->large_buf) {
3d9c2472 477 /* we are reusing a dirty large buf, clear its start */
1887f601 478 memset(server->bigbuf, 0, HEADER_SIZE(server));
3d9c2472
PS		 479 }
480
2a37ef94
JL		 481 if (!server->smallbuf) {
482 server->smallbuf = (char *)cifs_small_buf_get();
483 if (!server->smallbuf) {
f96637be 484 cifs_dbg(VFS, "No memory for SMB response\n");
3d9c2472
PS		 485 msleep(1000);
486 /* retry will check if exiting */
487 return false;
488 }
489 /* beginning of smb buffer is cleared in our buf_get */
490 } else {
491 /* if existing small buf clear beginning */
1887f601 492 memset(server->smallbuf, 0, HEADER_SIZE(server));
3d9c2472
PS		 493 }
494
3d9c2472
PS		 495 return true;
496}
497
ba749e6d
JL		 498static bool
499server_unresponsive(struct TCP_Server_Info *server)
500{
6dae51a5
PS		 501 /*
502 * We need to wait 2 echo intervals to make sure we handle such
503 * situations right:
504 * 1s client sends a normal SMB request
505 * 2s client gets a response
506 * 30s echo workqueue job pops, and decides we got a response recently
507 * and don't need to send another
508 * ...
509 * 65s kernel_recvmsg times out, and we see that we haven't gotten
510 * a response in >60s.
511 */
512 if (server->tcpStatus == CifsGood &&
adfeb3e0
SF		 513 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
514 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
515 server->hostname, (2 * server->echo_interval) / HZ);
ba749e6d
JL		 516 cifs_reconnect(server);
517 wake_up(&server->response_q);
518 return true;
519 }
520
521 return false;
522}
523
71335664
AV		 524static int
525cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
e7015fb1 526{
a52c1eb7
JL		 527 int length = 0;
528 int total_read;
e7015fb1 529
71335664
AV		 530 smb_msg->msg_control = NULL;
531 smb_msg->msg_controllen = 0;
e831e6cf 532
71335664 533 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
95edcff4
JL		 534 try_to_freeze();
535
71335664
AV		 536 if (server_unresponsive(server))
537 return -ECONNABORTED;
ba749e6d 538
71335664 539 length = sock_recvmsg(server->ssocket, smb_msg, 0);
42c4dfc2 540
71335664
AV		 541 if (server->tcpStatus == CifsExiting)
542 return -ESHUTDOWN;
e7015fb1 543
71335664 544 if (server->tcpStatus == CifsNeedReconnect) {
e7015fb1 545 cifs_reconnect(server);
71335664
AV		 546 return -ECONNABORTED;
547 }
548
549 if (length == -ERESTARTSYS ||
550 length == -EAGAIN ||
551 length == -EINTR) {
e7015fb1
PS		 552 /*
553 * Minimum sleep to prevent looping, allowing socket
554 * to clear and app threads to set tcpStatus
555 * CifsNeedReconnect if server hung.
556 */
557 usleep_range(1000, 2000);
558 length = 0;
a52c1eb7 559 continue;
71335664
AV		 560 }
561
562 if (length <= 0) {
09aab880 563 cifs_dbg(FYI, "Received no data or error: %d\n", length);
e7015fb1 564 cifs_reconnect(server);
71335664 565 return -ECONNABORTED;
e7015fb1
PS		 566 }
567 }
a52c1eb7 568 return total_read;
e7015fb1 569}
e7015fb1 570
e28bc5b1
JL		 571int
572cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
573 unsigned int to_read)
42c4dfc2 574{
71335664
AV		 575 struct msghdr smb_msg;
576 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
577 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
42c4dfc2 578
71335664
AV		 579 return cifs_readv_from_socket(server, &smb_msg);
580}
42c4dfc2 581
71335664
AV		 582int
583cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
584 unsigned int to_read)
585{
586 struct msghdr smb_msg;
587 struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
588 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
589 return cifs_readv_from_socket(server, &smb_msg);
e7015fb1
PS		 590}
591
98bac62c 592static bool
fe11e4cc 593is_smb_response(struct TCP_Server_Info *server, unsigned char type)
98bac62c 594{
98bac62c
PS		 595 /*
596 * The first byte big endian of the length field,
597 * is actually not part of the length but the type
598 * with the most common, zero, as regular data.
599 */
fe11e4cc
JL		 600 switch (type) {
601 case RFC1002_SESSION_MESSAGE:
602 /* Regular SMB response */
603 return true;
604 case RFC1002_SESSION_KEEP_ALIVE:
f96637be 605 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
fe11e4cc
JL		 606 break;
607 case RFC1002_POSITIVE_SESSION_RESPONSE:
f96637be 608 cifs_dbg(FYI, "RFC 1002 positive session response\n");
fe11e4cc
JL		 609 break;
610 case RFC1002_NEGATIVE_SESSION_RESPONSE:
98bac62c
PS		 611 /*
612 * We get this from Windows 98 instead of an error on
613 * SMB negprot response.
614 */
f96637be 615 cifs_dbg(FYI, "RFC 1002 negative session response\n");
98bac62c
PS		 616 /* give server a second to clean up */
617 msleep(1000);
618 /*
619 * Always try 445 first on reconnect since we get NACK
620 * on some if we ever connected to port 139 (the NACK
621 * is since we do not begin with RFC1001 session
622 * initialize frame).
623 */
fe11e4cc 624 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
98bac62c
PS		 625 cifs_reconnect(server);
626 wake_up(&server->response_q);
fe11e4cc
JL		 627 break;
628 default:
f96637be 629 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
98bac62c 630 cifs_reconnect(server);
98bac62c
PS		 631 }
632
fe11e4cc 633 return false;
98bac62c
PS		 634}
635
e28bc5b1
JL		 636void
637dequeue_mid(struct mid_q_entry *mid, bool malformed)
ea1f4502 638{
ad69bae1 639#ifdef CONFIG_CIFS_STATS2
ea1f4502 640 mid->when_received = jiffies;
ad69bae1 641#endif
ea1f4502
JL		 642 spin_lock(&GlobalMid_Lock);
643 if (!malformed)
7c9421e1 644 mid->mid_state = MID_RESPONSE_RECEIVED;
ea1f4502 645 else
7c9421e1 646 mid->mid_state = MID_RESPONSE_MALFORMED;
ea1f4502 647 list_del_init(&mid->qhead);
ad69bae1 648 spin_unlock(&GlobalMid_Lock);
ea1f4502 649}
ad69bae1 650
c8054ebd
JL		 651static void
652handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
d4e4854f 653 char *buf, int malformed)
ea1f4502 654{
316cf94a
PS		 655 if (server->ops->check_trans2 &&
656 server->ops->check_trans2(mid, server, buf, malformed))
c8054ebd 657 return;
ea1f4502 658 mid->resp_buf = buf;
7c9421e1 659 mid->large_buf = server->large_buf;
2a37ef94
JL		 660 /* Was previous buf put in mpx struct for multi-rsp? */
661 if (!mid->multiRsp) {
662 /* smb buffer will be freed by user thread */
663 if (server->large_buf)
664 server->bigbuf = NULL;
665 else
666 server->smallbuf = NULL;
667 }
ffc00e27 668 dequeue_mid(mid, malformed);
ad69bae1
PS		 669}
670
762dfd10
PS		 671static void clean_demultiplex_info(struct TCP_Server_Info *server)
672{
673 int length;
674
675 /* take it off the list, if it's not already */
676 spin_lock(&cifs_tcp_ses_lock);
677 list_del_init(&server->tcp_ses_list);
678 spin_unlock(&cifs_tcp_ses_lock);
679
680 spin_lock(&GlobalMid_Lock);
681 server->tcpStatus = CifsExiting;
682 spin_unlock(&GlobalMid_Lock);
683 wake_up_all(&server->response_q);
684
2d86dbc9 685 /* check if we have blocked requests that need to free */
fc40f9cf 686 spin_lock(&server->req_lock);
2d86dbc9
PS		 687 if (server->credits <= 0)
688 server->credits = 1;
fc40f9cf 689 spin_unlock(&server->req_lock);
762dfd10
PS		 690 /*
691 * Although there should not be any requests blocked on this queue it
692 * can not hurt to be paranoid and try to wake up requests that may
693 * haven been blocked when more than 50 at time were on the wire to the
694 * same server - they now will see the session is in exit state and get
695 * out of SendReceive.
696 */
697 wake_up_all(&server->request_q);
698 /* give those requests time to exit */
699 msleep(125);
700
701 if (server->ssocket) {
702 sock_release(server->ssocket);
703 server->ssocket = NULL;
704 }
705
706 if (!list_empty(&server->pending_mid_q)) {
707 struct list_head dispose_list;
708 struct mid_q_entry *mid_entry;
709 struct list_head *tmp, *tmp2;
710
711 INIT_LIST_HEAD(&dispose_list);
712 spin_lock(&GlobalMid_Lock);
713 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
714 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
f96637be 715 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
7c9421e1 716 mid_entry->mid_state = MID_SHUTDOWN;
762dfd10
PS		 717 list_move(&mid_entry->qhead, &dispose_list);
718 }
719 spin_unlock(&GlobalMid_Lock);
720
721 /* now walk dispose list and issue callbacks */
722 list_for_each_safe(tmp, tmp2, &dispose_list) {
723 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
f96637be 724 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
762dfd10
PS		 725 list_del_init(&mid_entry->qhead);
726 mid_entry->callback(mid_entry);
727 }
728 /* 1/8th of sec is more than enough time for them to exit */
729 msleep(125);
730 }
731
732 if (!list_empty(&server->pending_mid_q)) {
733 /*
734 * mpx threads have not exited yet give them at least the smb
735 * send timeout time for long ops.
736 *
737 * Due to delays on oplock break requests, we need to wait at
738 * least 45 seconds before giving up on a request getting a
739 * response and going ahead and killing cifsd.
740 */
f96637be 741 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
762dfd10
PS		 742 msleep(46000);
743 /*
744 * If threads still have not exited they are probably never
745 * coming home not much else we can do but free the memory.
746 */
747 }
748
749 kfree(server->hostname);
750 kfree(server);
751
752 length = atomic_dec_return(&tcpSesAllocCount);
753 if (length > 0)
11d83360 754 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
762dfd10
PS		 755}
756
e9097ab4
JL		 757static int
758standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
759{
760 int length;
761 char *buf = server->smallbuf;
d4e4854f 762 unsigned int pdu_length = get_rfc1002_length(buf);
e9097ab4
JL		 763
764 /* make sure this will fit in a large buffer */
1887f601 765 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
f96637be 766 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
e9097ab4
JL		 767 cifs_reconnect(server);
768 wake_up(&server->response_q);
3fabaa27 769 return -ECONNABORTED;
e9097ab4
JL		 770 }
771
772 /* switch to large buffer if too big for a small one */
773 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
774 server->large_buf = true;
d4e4854f 775 memcpy(server->bigbuf, buf, server->total_read);
e9097ab4 776 buf = server->bigbuf;
e9097ab4
JL		 777 }
778
779 /* now read the rest */
1887f601
PS		 780 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
781 pdu_length - HEADER_SIZE(server) + 1 + 4);
e9097ab4
JL		 782 if (length < 0)
783 return length;
784 server->total_read += length;
785
d4e4854f 786 dump_smb(buf, server->total_read);
e9097ab4 787
4326ed2f
PS		 788 return cifs_handle_standard(server, mid);
789}
790
791int
792cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
793{
794 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
795 int length;
796
e9097ab4
JL		 797 /*
798 * We know that we received enough to get to the MID as we
799 * checked the pdu_length earlier. Now check to see
800 * if the rest of the header is OK. We borrow the length
801 * var for the rest of the loop to avoid a new stack var.
802 *
803 * 48 bytes is enough to display the header and a little bit
804 * into the payload for debugging purposes.
805 */
373512ec 806 length = server->ops->check_message(buf, server->total_read, server);
e9097ab4
JL		 807 if (length != 0)
808 cifs_dump_mem("Bad SMB: ", buf,
809 min_t(unsigned int, server->total_read, 48));
810
511c54a2
PS		 811 if (server->ops->is_session_expired &&
812 server->ops->is_session_expired(buf)) {
813 cifs_reconnect(server);
814 wake_up(&server->response_q);
815 return -1;
816 }
817
2e44b288
PS		 818 if (server->ops->is_status_pending &&
819 server->ops->is_status_pending(buf, server, length))
820 return -1;
821
ff4fa4a2
JL		 822 if (!mid)
823 return length;
e9097ab4 824
d4e4854f 825 handle_mid(mid, server, buf, length);
ff4fa4a2 826 return 0;
e9097ab4
JL		 827}
828
1da177e4 829static int
7c97c200 830cifs_demultiplex_thread(void *p)
1da177e4
LT		 831{
832 int length;
7c97c200 833 struct TCP_Server_Info *server = p;
2a37ef94
JL		 834 unsigned int pdu_length;
835 char *buf = NULL;
a5c3e1c7 836 struct task_struct *task_to_wake = NULL;
1da177e4 837 struct mid_q_entry *mid_entry;
1da177e4 838
1da177e4 839 current->flags |= PF_MEMALLOC;
f96637be 840 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
93d0ec85
JL		 841
842 length = atomic_inc_return(&tcpSesAllocCount);
843 if (length > 1)
11d83360 844 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1da177e4 845
83144186 846 set_freezable();
469ee614 847 while (server->tcpStatus != CifsExiting) {
ede1327e
SF		 848 if (try_to_freeze())
849 continue;
b8643e1b 850
2a37ef94 851 if (!allocate_buffers(server))
3d9c2472 852 continue;
b8643e1b 853
2a37ef94 854 server->large_buf = false;
2a37ef94 855 buf = server->smallbuf;
f01d5e14 856 pdu_length = 4; /* enough to get RFC1001 header */
fda35943 857
e28bc5b1 858 length = cifs_read_from_socket(server, buf, pdu_length);
a52c1eb7 859 if (length < 0)
1da177e4 860 continue;
2a37ef94 861 server->total_read = length;
1da177e4 862
98bac62c
PS		 863 /*
864 * The right amount was read from socket - 4 bytes,
865 * so we can now interpret the length field.
866 */
d4e4854f 867 pdu_length = get_rfc1002_length(buf);
70ca734a 868
f96637be 869 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
fe11e4cc 870 if (!is_smb_response(server, buf[0]))
fb8c4b14 871 continue;
e4eb295d 872
89482a56 873 /* make sure we have enough to get to the MID */
1887f601 874 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
f96637be
JP		 875 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
876 pdu_length);
89482a56
JL		 877 cifs_reconnect(server);
878 wake_up(&server->response_q);
879 continue;
e4eb295d 880 }
e7015fb1 881
89482a56 882 /* read down to the MID */
e28bc5b1 883 length = cifs_read_from_socket(server, buf + 4,
1887f601 884 HEADER_SIZE(server) - 1 - 4);
89482a56 885 if (length < 0)
e4eb295d 886 continue;
2a37ef94 887 server->total_read += length;
1da177e4 888
9bb17e09
PS		 889 if (server->ops->is_transform_hdr &&
890 server->ops->receive_transform &&
891 server->ops->is_transform_hdr(buf)) {
892 length = server->ops->receive_transform(server,
893 &mid_entry);
894 } else {
895 mid_entry = server->ops->find_mid(server, buf);
50c2f753 896
9bb17e09
PS		 897 if (!mid_entry || !mid_entry->receive)
898 length = standard_receive3(server, mid_entry);
899 else
900 length = mid_entry->receive(server, mid_entry);
901 }
71823baf 902
e9097ab4 903 if (length < 0)
fe11e4cc 904 continue;
1da177e4 905
d4e4854f 906 if (server->large_buf)
2a37ef94 907 buf = server->bigbuf;
fda35943 908
fda35943 909 server->lstrp = jiffies;
2b84a36c 910 if (mid_entry != NULL) {
38bd4906
SP		 911 if ((mid_entry->mid_flags & MID_WAIT_CANCELLED) &&
912 mid_entry->mid_state == MID_RESPONSE_RECEIVED &&
913 server->ops->handle_cancelled_mid)
914 server->ops->handle_cancelled_mid(
915 mid_entry->resp_buf,
916 server);
917
2a37ef94
JL		 918 if (!mid_entry->multiRsp || mid_entry->multiEnd)
919 mid_entry->callback(mid_entry);
38bd4906
SP		 920 } else if (server->ops->is_oplock_break &&
921 server->ops->is_oplock_break(buf, server)) {
922 cifs_dbg(FYI, "Received oplock break\n");
923 } else {
f96637be
JP		 924 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
925 atomic_read(&midCount));
1887f601
PS		 926 cifs_dump_mem("Received Data is: ", buf,
927 HEADER_SIZE(server));
3979877e 928#ifdef CONFIG_CIFS_DEBUG2
7f0adb53
PS		 929 if (server->ops->dump_detail)
930 server->ops->dump_detail(buf);
3979877e
SF		 931 cifs_dump_mids(server);
932#endif /* CIFS_DEBUG2 */
50c2f753 933
e4eb295d
SF		 934 }
935 } /* end while !EXITING */
936
fd62cb7e 937 /* buffer usually freed in free_mid - need to free it here on exit */
2a37ef94
JL		 938 cifs_buf_release(server->bigbuf);
939 if (server->smallbuf) /* no sense logging a debug message if NULL */
940 cifs_small_buf_release(server->smallbuf);
1da177e4 941
a5c3e1c7 942 task_to_wake = xchg(&server->tsk, NULL);
762dfd10 943 clean_demultiplex_info(server);
a5c3e1c7
SF		 944
945 /* if server->tsk was NULL then wait for a signal before exiting */
946 if (!task_to_wake) {
947 set_current_state(TASK_INTERRUPTIBLE);
948 while (!signal_pending(current)) {
949 schedule();
950 set_current_state(TASK_INTERRUPTIBLE);
951 }
952 set_current_state(TASK_RUNNING);
953 }
954
0468a2cf 955 module_put_and_exit(0);
1da177e4
LT		 956}
957
c359cf3c
JL		 958/* extract the host portion of the UNC string */
959static char *
960extract_hostname(const char *unc)
961{
962 const char *src;
963 char *dst, *delim;
964 unsigned int len;
965
966 /* skip double chars at beginning of string */
967 /* BB: check validity of these bytes? */
968 src = unc + 2;
969
970 /* delimiter between hostname and sharename is always '\\' now */
971 delim = strchr(src, '\\');
972 if (!delim)
973 return ERR_PTR(-EINVAL);
974
975 len = delim - src;
976 dst = kmalloc((len + 1), GFP_KERNEL);
977 if (dst == NULL)
978 return ERR_PTR(-ENOMEM);
979
980 memcpy(dst, src, len);
981 dst[len] = '\0';
982
983 return dst;
984}
985
8830d7e0
SP		 986static int get_option_ul(substring_t args[], unsigned long *option)
987{
988 int rc;
989 char *string;
990
991 string = match_strdup(args);
992 if (string == NULL)
993 return -ENOMEM;
bfa890a3 994 rc = kstrtoul(string, 0, option);
8830d7e0
SP		 995 kfree(string);
996
997 return rc;
998}
999
3da46565
EB		 1000static int get_option_uid(substring_t args[], kuid_t *result)
1001{
1002 unsigned long value;
1003 kuid_t uid;
1004 int rc;
1005
1006 rc = get_option_ul(args, &value);
1007 if (rc)
1008 return rc;
1009
1010 uid = make_kuid(current_user_ns(), value);
1011 if (!uid_valid(uid))
1012 return -EINVAL;
1013
1014 *result = uid;
1015 return 0;
1016}
1017
1018static int get_option_gid(substring_t args[], kgid_t *result)
1019{
1020 unsigned long value;
1021 kgid_t gid;
1022 int rc;
1023
1024 rc = get_option_ul(args, &value);
1025 if (rc)
1026 return rc;
1027
1028 gid = make_kgid(current_user_ns(), value);
1029 if (!gid_valid(gid))
1030 return -EINVAL;
1031
1032 *result = gid;
1033 return 0;
1034}
8830d7e0
SP		 1035
1036static int cifs_parse_security_flavors(char *value,
1037 struct smb_vol *vol)
1038{
1039
1040 substring_t args[MAX_OPT_ARGS];
1041
1e3cc57e
JL		 1042 /*
1043 * With mount options, the last one should win. Reset any existing
1044 * settings back to default.
1045 */
1046 vol->sectype = Unspecified;
1047 vol->sign = false;
1048
8830d7e0 1049 switch (match_token(value, cifs_secflavor_tokens, args)) {
3f618223
JL		 1050 case Opt_sec_krb5p:
1051 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1052 return 1;
1053 case Opt_sec_krb5i:
1054 vol->sign = true;
1055 /* Fallthrough */
8830d7e0 1056 case Opt_sec_krb5:
1e3cc57e 1057 vol->sectype = Kerberos;
8830d7e0 1058 break;
3f618223 1059 case Opt_sec_ntlmsspi:
1e3cc57e 1060 vol->sign = true;
3f618223 1061 /* Fallthrough */
8830d7e0 1062 case Opt_sec_ntlmssp:
1e3cc57e 1063 vol->sectype = RawNTLMSSP;
8830d7e0 1064 break;
3f618223 1065 case Opt_sec_ntlmi:
1e3cc57e 1066 vol->sign = true;
3f618223 1067 /* Fallthrough */
8830d7e0 1068 case Opt_ntlm:
1e3cc57e 1069 vol->sectype = NTLM;
8830d7e0 1070 break;
3f618223 1071 case Opt_sec_ntlmv2i:
1e3cc57e 1072 vol->sign = true;
3f618223 1073 /* Fallthrough */
7659624f 1074 case Opt_sec_ntlmv2:
1e3cc57e 1075 vol->sectype = NTLMv2;
8830d7e0
SP		 1076 break;
1077#ifdef CONFIG_CIFS_WEAK_PW_HASH
1078 case Opt_sec_lanman:
1e3cc57e 1079 vol->sectype = LANMAN;
8830d7e0
SP		 1080 break;
1081#endif
1082 case Opt_sec_none:
1083 vol->nullauth = 1;
1084 break;
1085 default:
f96637be 1086 cifs_dbg(VFS, "bad security option: %s\n", value);
8830d7e0
SP		 1087 return 1;
1088 }
1089
1090 return 0;
1091}
1092
15b6a473
JL		 1093static int
1094cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1095{
1096 substring_t args[MAX_OPT_ARGS];
1097
1098 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1099 case Opt_cache_loose:
1100 vol->direct_io = false;
1101 vol->strict_io = false;
1102 break;
1103 case Opt_cache_strict:
1104 vol->direct_io = false;
1105 vol->strict_io = true;
1106 break;
1107 case Opt_cache_none:
1108 vol->direct_io = true;
1109 vol->strict_io = false;
1110 break;
1111 default:
f96637be 1112 cifs_dbg(VFS, "bad cache= option: %s\n", value);
15b6a473
JL		 1113 return 1;
1114 }
1115 return 0;
1116}
1117
23db65f5
JL		 1118static int
1119cifs_parse_smb_version(char *value, struct smb_vol *vol)
1120{
1121 substring_t args[MAX_OPT_ARGS];
1122
1123 switch (match_token(value, cifs_smb_version_tokens, args)) {
1124 case Smb_1:
1125 vol->ops = &smb1_operations;
1126 vol->vals = &smb1_values;
1127 break;
dd446b16 1128 case Smb_20:
53ef1016 1129 vol->ops = &smb20_operations;
dd446b16
SF		 1130 vol->vals = &smb20_values;
1131 break;
1080ef75
SF		 1132 case Smb_21:
1133 vol->ops = &smb21_operations;
1134 vol->vals = &smb21_values;
1135 break;
e4aa25e7 1136 case Smb_30:
38107d45 1137 vol->ops = &smb30_operations;
e4aa25e7
SF		 1138 vol->vals = &smb30_values;
1139 break;
20b6d8b4
SF		 1140 case Smb_302:
1141 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1142 vol->vals = &smb302_values;
1143 break;
5f7fbf73
SF		 1144#ifdef CONFIG_CIFS_SMB311
1145 case Smb_311:
aab1893d 1146 vol->ops = &smb311_operations;
5f7fbf73
SF		 1147 vol->vals = &smb311_values;
1148 break;
1149#endif /* SMB311 */
23db65f5 1150 default:
f96637be 1151 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
23db65f5
JL		 1152 return 1;
1153 }
1154 return 0;
1155}
1156
d387a5c5
JL		 1157/*
1158 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1159 * fields with the result. Returns 0 on success and an error otherwise.
1160 */
1161static int
1162cifs_parse_devname(const char *devname, struct smb_vol *vol)
1163{
1164 char *pos;
1165 const char *delims = "/\\";
1166 size_t len;
1167
1168 /* make sure we have a valid UNC double delimiter prefix */
1169 len = strspn(devname, delims);
1170 if (len != 2)
1171 return -EINVAL;
1172
1173 /* find delimiter between host and sharename */
1174 pos = strpbrk(devname + 2, delims);
1175 if (!pos)
1176 return -EINVAL;
1177
1178 /* skip past delimiter */
1179 ++pos;
1180
1181 /* now go until next delimiter or end of string */
1182 len = strcspn(pos, delims);
1183
1184 /* move "pos" up to delimiter or NULL */
1185 pos += len;
1186 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1187 if (!vol->UNC)
1188 return -ENOMEM;
1189
1190 convert_delimiter(vol->UNC, '\\');
1191
11e31647
SP		 1192 /* skip any delimiter */
1193 if (*pos == '/' || *pos == '\\')
1194 pos++;
1195
1196 /* If pos is NULL then no prepath */
1197 if (!*pos)
d387a5c5
JL		 1198 return 0;
1199
1200 vol->prepath = kstrdup(pos, GFP_KERNEL);
1201 if (!vol->prepath)
1202 return -ENOMEM;
1203
1204 return 0;
1205}
1206
1da177e4 1207static int
b946845a 1208cifs_parse_mount_options(const char *mountdata, const char *devname,
50c2f753 1209 struct smb_vol *vol)
1da177e4 1210{
8830d7e0 1211 char *data, *end;
957df453 1212 char *mountdata_copy = NULL, *options;
1da177e4
LT		 1213 unsigned int temp_len, i, j;
1214 char separator[2];
9b9d6b24
JL		 1215 short int override_uid = -1;
1216 short int override_gid = -1;
1217 bool uid_specified = false;
1218 bool gid_specified = false;
d8162558
JL		 1219 bool sloppy = false;
1220 char *invalid = NULL;
88463999 1221 char *nodename = utsname()->nodename;
8830d7e0
SP		 1222 char *string = NULL;
1223 char *tmp_end, *value;
1224 char delim;
b979aaa1 1225 bool got_ip = false;
7e682f76 1226 bool got_version = false;
b979aaa1
JL		 1227 unsigned short port = 0;
1228 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1da177e4
LT		 1229
1230 separator[0] = ',';
50c2f753 1231 separator[1] = 0;
8830d7e0 1232 delim = separator[0];
1da177e4 1233
6ee9542a
JL		 1234 /* ensure we always start with zeroed-out smb_vol */
1235 memset(vol, 0, sizeof(*vol));
1236
88463999
JL		 1237 /*
1238 * does not have to be perfect mapping since field is
1239 * informational, only used for servers that do not support
1240 * port 445 and it can be overridden at mount time
1241 */
1397f2ee
JL		 1242 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1243 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
88463999
JL		 1244 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1245
1397f2ee 1246 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
a10faeb2
SF		 1247 /* null target name indicates to use *SMBSERVR default called name
1248 if we end up sending RFC1001 session initialize */
1249 vol->target_rfc1001_name[0] = 0;
3e4b3e1f
JL		 1250 vol->cred_uid = current_uid();
1251 vol->linux_uid = current_uid();
a001e5b5 1252 vol->linux_gid = current_gid();
f55ed1a8 1253
2baa2682
SF		 1254 /*
1255 * default to SFM style remapping of seven reserved characters
1256 * unless user overrides it or we negotiate CIFS POSIX where
1257 * it is unnecessary. Can not simultaneously use more than one mapping
1258 * since then readdir could list files that open could not open
1259 */
1260 vol->remap = true;
1261
f55ed1a8
JL		 1262 /* default to only allowing write access to owner of the mount */
1263 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1da177e4
LT		 1264
1265 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
ac67055e
JA		 1266 /* default is always to request posix paths. */
1267 vol->posix_paths = 1;
a0c9217f
JL		 1268 /* default to using server inode numbers where available */
1269 vol->server_ino = 1;
ac67055e 1270
1b359204
JL		 1271 /* default is to use strict cifs caching semantics */
1272 vol->strict_io = true;
1273
6d20e840
SJ		 1274 vol->actimeo = CIFS_DEF_ACTIMEO;
1275
eef914a9
SF		 1276 /* FIXME: add autonegotiation for SMB3 or later rather than just SMB3 */
1277 vol->ops = &smb30_operations; /* both secure and accepted widely */
1278 vol->vals = &smb30_values;
23db65f5 1279
b782fcc1
RV		 1280 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1281
b946845a
SF		 1282 if (!mountdata)
1283 goto cifs_parse_mount_err;
1284
1285 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1286 if (!mountdata_copy)
1287 goto cifs_parse_mount_err;
1da177e4 1288
b946845a 1289 options = mountdata_copy;
4906e50b 1290 end = options + strlen(options);
8830d7e0 1291
50c2f753 1292 if (strncmp(options, "sep=", 4) == 0) {
fb8c4b14 1293 if (options[4] != 0) {
1da177e4
LT		 1294 separator[0] = options[4];
1295 options += 5;
1296 } else {
f96637be 1297 cifs_dbg(FYI, "Null separator not allowed\n");
1da177e4
LT		 1298 }
1299 }
3d3ea8e6
SP		 1300 vol->backupuid_specified = false; /* no backup intent for a user */
1301 vol->backupgid_specified = false; /* no backup intent for a group */
50c2f753 1302
37d4f99b
JL		 1303 switch (cifs_parse_devname(devname, vol)) {
1304 case 0:
1305 break;
1306 case -ENOMEM:
1307 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1308 goto cifs_parse_mount_err;
1309 case -EINVAL:
1310 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1311 goto cifs_parse_mount_err;
1312 default:
1313 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1314 goto cifs_parse_mount_err;
d387a5c5
JL		 1315 }
1316
1da177e4 1317 while ((data = strsep(&options, separator)) != NULL) {
8830d7e0
SP		 1318 substring_t args[MAX_OPT_ARGS];
1319 unsigned long option;
1320 int token;
1321
1da177e4
LT		 1322 if (!*data)
1323 continue;
1da177e4 1324
8830d7e0
SP		 1325 token = match_token(data, cifs_mount_option_tokens, args);
1326
1327 switch (token) {
1328
1329 /* Ingnore the following */
1330 case Opt_ignore:
1331 break;
1332
1333 /* Boolean values */
1334 case Opt_user_xattr:
1da177e4 1335 vol->no_xattr = 0;
8830d7e0
SP		 1336 break;
1337 case Opt_nouser_xattr:
1da177e4 1338 vol->no_xattr = 1;
8830d7e0
SP		 1339 break;
1340 case Opt_forceuid:
9b9d6b24 1341 override_uid = 1;
8830d7e0
SP		 1342 break;
1343 case Opt_noforceuid:
9b9d6b24 1344 override_uid = 0;
8830d7e0 1345 break;
72bd481f
JL		 1346 case Opt_forcegid:
1347 override_gid = 1;
1348 break;
1349 case Opt_noforcegid:
1350 override_gid = 0;
1351 break;
8830d7e0 1352 case Opt_noblocksend:
edf1ae40 1353 vol->noblocksnd = 1;
8830d7e0
SP		 1354 break;
1355 case Opt_noautotune:
edf1ae40 1356 vol->noautotune = 1;
8830d7e0
SP		 1357 break;
1358 case Opt_hard:
1da177e4 1359 vol->retry = 1;
8830d7e0
SP		 1360 break;
1361 case Opt_soft:
1da177e4 1362 vol->retry = 0;
8830d7e0
SP		 1363 break;
1364 case Opt_perm:
1da177e4 1365 vol->noperm = 0;
8830d7e0
SP		 1366 break;
1367 case Opt_noperm:
1da177e4 1368 vol->noperm = 1;
8830d7e0
SP		 1369 break;
1370 case Opt_mapchars:
2baa2682
SF		 1371 vol->sfu_remap = true;
1372 vol->remap = false; /* disable SFM mapping */
8830d7e0
SP		 1373 break;
1374 case Opt_nomapchars:
2baa2682
SF		 1375 vol->sfu_remap = false;
1376 break;
1377 case Opt_mapposix:
1378 vol->remap = true;
1379 vol->sfu_remap = false; /* disable SFU mapping */
1380 break;
1381 case Opt_nomapposix:
1382 vol->remap = false;
8830d7e0
SP		 1383 break;
1384 case Opt_sfu:
50c2f753 1385 vol->sfu_emul = 1;
8830d7e0
SP		 1386 break;
1387 case Opt_nosfu:
50c2f753 1388 vol->sfu_emul = 0;
8830d7e0
SP		 1389 break;
1390 case Opt_nodfs:
2c1b8615 1391 vol->nodfs = 1;
8830d7e0
SP		 1392 break;
1393 case Opt_posixpaths:
ac67055e 1394 vol->posix_paths = 1;
8830d7e0
SP		 1395 break;
1396 case Opt_noposixpaths:
ac67055e 1397 vol->posix_paths = 0;
8830d7e0
SP		 1398 break;
1399 case Opt_nounix:
c18c842b 1400 vol->no_linux_ext = 1;
8830d7e0
SP		 1401 break;
1402 case Opt_nocase:
50c2f753 1403 vol->nocase = 1;
8830d7e0
SP		 1404 break;
1405 case Opt_brl:
c46fa8ac 1406 vol->nobrl = 0;
8830d7e0
SP		 1407 break;
1408 case Opt_nobrl:
c46fa8ac 1409 vol->nobrl = 1;
5cfdddcf
PS		 1410 /*
1411 * turn off mandatory locking in mode
8830d7e0 1412 * if remote locking is turned off since the
5cfdddcf
PS		 1413 * local vfs will do advisory
1414 */
50c2f753
SF		 1415 if (vol->file_mode ==
1416 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
d3485d37 1417 vol->file_mode = S_IALLUGO;
8830d7e0
SP		 1418 break;
1419 case Opt_forcemandatorylock:
13a6e42a 1420 vol->mand_lock = 1;
8830d7e0
SP		 1421 break;
1422 case Opt_setuids:
1da177e4 1423 vol->setuids = 1;
8830d7e0
SP		 1424 break;
1425 case Opt_nosetuids:
1da177e4 1426 vol->setuids = 0;
8830d7e0 1427 break;
95932655
SF		 1428 case Opt_setuidfromacl:
1429 vol->setuidfromacl = 1;
1430 break;
8830d7e0 1431 case Opt_dynperm:
d0a9c078 1432 vol->dynperm = true;
8830d7e0
SP		 1433 break;
1434 case Opt_nodynperm:
d0a9c078 1435 vol->dynperm = false;
8830d7e0
SP		 1436 break;
1437 case Opt_nohard:
1da177e4 1438 vol->retry = 0;
8830d7e0
SP		 1439 break;
1440 case Opt_nosoft:
1da177e4 1441 vol->retry = 1;
8830d7e0
SP		 1442 break;
1443 case Opt_nointr:
1da177e4 1444 vol->intr = 0;
8830d7e0
SP		 1445 break;
1446 case Opt_intr:
1da177e4 1447 vol->intr = 1;
8830d7e0
SP		 1448 break;
1449 case Opt_nostrictsync:
be652445 1450 vol->nostrictsync = 1;
8830d7e0
SP		 1451 break;
1452 case Opt_strictsync:
be652445 1453 vol->nostrictsync = 0;
8830d7e0
SP		 1454 break;
1455 case Opt_serverino:
1da177e4 1456 vol->server_ino = 1;
8830d7e0
SP		 1457 break;
1458 case Opt_noserverino:
1da177e4 1459 vol->server_ino = 0;
8830d7e0
SP		 1460 break;
1461 case Opt_rwpidforward:
d4ffff1f 1462 vol->rwpidforward = 1;
8830d7e0
SP		 1463 break;
1464 case Opt_cifsacl:
0a4b92c0 1465 vol->cifs_acl = 1;
8830d7e0
SP		 1466 break;
1467 case Opt_nocifsacl:
0a4b92c0 1468 vol->cifs_acl = 0;
8830d7e0
SP		 1469 break;
1470 case Opt_acl:
1da177e4 1471 vol->no_psx_acl = 0;
8830d7e0
SP		 1472 break;
1473 case Opt_noacl:
1da177e4 1474 vol->no_psx_acl = 1;
8830d7e0
SP		 1475 break;
1476 case Opt_locallease:
84210e91 1477 vol->local_lease = 1;
8830d7e0
SP		 1478 break;
1479 case Opt_sign:
1e3cc57e 1480 vol->sign = true;
8830d7e0
SP		 1481 break;
1482 case Opt_seal:
95b1cb90 1483 /* we do not do the following in secFlags because seal
8830d7e0
SP		 1484 * is a per tree connection (mount) not a per socket
1485 * or per-smb connection option in the protocol
1486 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1487 */
95b1cb90 1488 vol->seal = 1;
8830d7e0 1489 break;
8830d7e0 1490 case Opt_noac:
0b456f04 1491 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
8830d7e0
SP		 1492 break;
1493 case Opt_fsc:
607a569d 1494#ifndef CONFIG_CIFS_FSCACHE
f96637be 1495 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
b946845a 1496 goto cifs_parse_mount_err;
607a569d 1497#endif
fa1df75d 1498 vol->fsc = true;
8830d7e0
SP		 1499 break;
1500 case Opt_mfsymlinks:
736a3320 1501 vol->mfsymlinks = true;
8830d7e0
SP		 1502 break;
1503 case Opt_multiuser:
0eb8a132 1504 vol->multiuser = true;
8830d7e0 1505 break;
d8162558
JL		 1506 case Opt_sloppy:
1507 sloppy = true;
1508 break;
a0b3df5c
JL		 1509 case Opt_nosharesock:
1510 vol->nosharesock = true;
1511 break;
b2a30774
SF		 1512 case Opt_nopersistent:
1513 vol->nopersistent = true;
1514 if (vol->persistent) {
1515 cifs_dbg(VFS,
1516 "persistenthandles mount options conflict\n");
1517 goto cifs_parse_mount_err;
1518 }
1519 break;
1520 case Opt_persistent:
1521 vol->persistent = true;
592fafe6 1522 if ((vol->nopersistent) || (vol->resilient)) {
b2a30774
SF		 1523 cifs_dbg(VFS,
1524 "persistenthandles mount options conflict\n");
1525 goto cifs_parse_mount_err;
1526 }
1527 break;
592fafe6
SF		 1528 case Opt_resilient:
1529 vol->resilient = true;
1530 if (vol->persistent) {
1531 cifs_dbg(VFS,
1532 "persistenthandles mount options conflict\n");
1533 goto cifs_parse_mount_err;
1534 }
1535 break;
1536 case Opt_noresilient:
1537 vol->resilient = false; /* already the default */
1538 break;
39566443
GP		 1539 case Opt_domainauto:
1540 vol->domainauto = true;
1541 break;
8830d7e0
SP		 1542
1543 /* Numeric Values */
1544 case Opt_backupuid:
3da46565 1545 if (get_option_uid(args, &vol->backupuid)) {
f96637be
JP		 1546 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1547 __func__);
3d3ea8e6
SP		 1548 goto cifs_parse_mount_err;
1549 }
1550 vol->backupuid_specified = true;
8830d7e0
SP		 1551 break;
1552 case Opt_backupgid:
3da46565 1553 if (get_option_gid(args, &vol->backupgid)) {
f96637be
JP		 1554 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1555 __func__);
3d3ea8e6
SP		 1556 goto cifs_parse_mount_err;
1557 }
1558 vol->backupgid_specified = true;
8830d7e0
SP		 1559 break;
1560 case Opt_uid:
3da46565 1561 if (get_option_uid(args, &vol->linux_uid)) {
f96637be
JP		 1562 cifs_dbg(VFS, "%s: Invalid uid value\n",
1563 __func__);
8830d7e0
SP		 1564 goto cifs_parse_mount_err;
1565 }
8830d7e0
SP		 1566 uid_specified = true;
1567 break;
1568 case Opt_cruid:
3da46565 1569 if (get_option_uid(args, &vol->cred_uid)) {
f96637be
JP		 1570 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1571 __func__);
8830d7e0
SP		 1572 goto cifs_parse_mount_err;
1573 }
8830d7e0
SP		 1574 break;
1575 case Opt_gid:
3da46565 1576 if (get_option_gid(args, &vol->linux_gid)) {
f96637be
JP		 1577 cifs_dbg(VFS, "%s: Invalid gid value\n",
1578 __func__);
8830d7e0
SP		 1579 goto cifs_parse_mount_err;
1580 }
8830d7e0
SP		 1581 gid_specified = true;
1582 break;
1583 case Opt_file_mode:
1584 if (get_option_ul(args, &option)) {
f96637be
JP		 1585 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1586 __func__);
8830d7e0
SP		 1587 goto cifs_parse_mount_err;
1588 }
1589 vol->file_mode = option;
1590 break;
1591 case Opt_dirmode:
1592 if (get_option_ul(args, &option)) {
f96637be
JP		 1593 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1594 __func__);
8830d7e0
SP		 1595 goto cifs_parse_mount_err;
1596 }
1597 vol->dir_mode = option;
1598 break;
1599 case Opt_port:
b979aaa1
JL		 1600 if (get_option_ul(args, &option) ||
1601 option > USHRT_MAX) {
f96637be
JP		 1602 cifs_dbg(VFS, "%s: Invalid port value\n",
1603 __func__);
8830d7e0
SP		 1604 goto cifs_parse_mount_err;
1605 }
b979aaa1 1606 port = (unsigned short)option;
8830d7e0
SP		 1607 break;
1608 case Opt_rsize:
1609 if (get_option_ul(args, &option)) {
f96637be
JP		 1610 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1611 __func__);
b946845a 1612 goto cifs_parse_mount_err;
8830d7e0
SP		 1613 }
1614 vol->rsize = option;
1615 break;
1616 case Opt_wsize:
1617 if (get_option_ul(args, &option)) {
f96637be
JP		 1618 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1619 __func__);
8830d7e0
SP		 1620 goto cifs_parse_mount_err;
1621 }
1622 vol->wsize = option;
1623 break;
1624 case Opt_actimeo:
1625 if (get_option_ul(args, &option)) {
f96637be
JP		 1626 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1627 __func__);
8830d7e0
SP		 1628 goto cifs_parse_mount_err;
1629 }
1630 vol->actimeo = HZ * option;
1631 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
f96637be 1632 cifs_dbg(VFS, "attribute cache timeout too large\n");
8830d7e0
SP		 1633 goto cifs_parse_mount_err;
1634 }
1635 break;
adfeb3e0
SF		 1636 case Opt_echo_interval:
1637 if (get_option_ul(args, &option)) {
1638 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1639 __func__);
1640 goto cifs_parse_mount_err;
1641 }
1642 vol->echo_interval = option;
1643 break;
8b217fe7
SF		 1644 case Opt_snapshot:
1645 if (get_option_ul(args, &option)) {
1646 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1647 __func__);
1648 goto cifs_parse_mount_err;
1649 }
1650 vol->snapshot_time = option;
1651 break;
141891f4
SF		 1652 case Opt_max_credits:
1653 if (get_option_ul(args, &option) || (option < 20) ||
1654 (option > 60000)) {
1655 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1656 __func__);
1657 goto cifs_parse_mount_err;
1658 }
1659 vol->max_credits = option;
1660 break;
8830d7e0
SP		 1661
1662 /* String Arguments */
1663
4fe9e963
SP		 1664 case Opt_blank_user:
1665 /* null user, ie. anonymous authentication */
1666 vol->nullauth = 1;
1667 vol->username = NULL;
1668 break;
8830d7e0
SP		 1669 case Opt_user:
1670 string = match_strdup(args);
1671 if (string == NULL)
1672 goto out_nomem;
1673
8c3a2b4c
SL		 1674 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1675 CIFS_MAX_USERNAME_LEN) {
0b456f04 1676 pr_warn("CIFS: username too long\n");
8830d7e0
SP		 1677 goto cifs_parse_mount_err;
1678 }
2bd50fb3
TK		 1679
1680 kfree(vol->username);
8830d7e0 1681 vol->username = kstrdup(string, GFP_KERNEL);
f96637be 1682 if (!vol->username)
8830d7e0 1683 goto cifs_parse_mount_err;
8830d7e0
SP		 1684 break;
1685 case Opt_blank_pass:
8830d7e0
SP		 1686 /* passwords have to be handled differently
1687 * to allow the character used for deliminator
1688 * to be passed within them
1689 */
1690
c369c9a4
SP		 1691 /*
1692 * Check if this is a case where the password
1693 * starts with a delimiter
1694 */
1695 tmp_end = strchr(data, '=');
1696 tmp_end++;
1697 if (!(tmp_end < end && tmp_end[1] == delim)) {
1698 /* No it is not. Set the password to NULL */
d6ccf499 1699 kfree(vol->password);
c369c9a4
SP		 1700 vol->password = NULL;
1701 break;
1702 }
1703 /* Yes it is. Drop down to Opt_pass below.*/
1704 case Opt_pass:
8830d7e0
SP		 1705 /* Obtain the value string */
1706 value = strchr(data, '=');
10238074 1707 value++;
8830d7e0
SP		 1708
1709 /* Set tmp_end to end of the string */
1710 tmp_end = (char *) value + strlen(value);
1711
1712 /* Check if following character is the deliminator
1713 * If yes, we have encountered a double deliminator
1714 * reset the NULL character to the deliminator
1715 */
e73f843a 1716 if (tmp_end < end && tmp_end[1] == delim) {
8830d7e0
SP		 1717 tmp_end[0] = delim;
1718
e73f843a
SJ		 1719 /* Keep iterating until we get to a single
1720 * deliminator OR the end
1721 */
1722 while ((tmp_end = strchr(tmp_end, delim))
1723 != NULL && (tmp_end[1] == delim)) {
1724 tmp_end = (char *) &tmp_end[2];
1725 }
1726
1727 /* Reset var options to point to next element */
1728 if (tmp_end) {
1729 tmp_end[0] = '\0';
1730 options = (char *) &tmp_end[1];
1731 } else
1732 /* Reached the end of the mount option
1733 * string */
1734 options = end;
8830d7e0
SP		 1735 }
1736
d6ccf499 1737 kfree(vol->password);
8830d7e0
SP		 1738 /* Now build new password string */
1739 temp_len = strlen(value);
1740 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1741 if (vol->password == NULL) {
0b456f04 1742 pr_warn("CIFS: no memory for password\n");
8830d7e0
SP		 1743 goto cifs_parse_mount_err;
1744 }
1745
1746 for (i = 0, j = 0; i < temp_len; i++, j++) {
1747 vol->password[j] = value[i];
1748 if ((value[i] == delim) &&
1749 value[i+1] == delim)
1750 /* skip the second deliminator */
1751 i++;
1752 }
1753 vol->password[j] = '\0';
1754 break;
4fe9e963 1755 case Opt_blank_ip:
b979aaa1
JL		 1756 /* FIXME: should this be an error instead? */
1757 got_ip = false;
4fe9e963 1758 break;
8830d7e0
SP		 1759 case Opt_ip:
1760 string = match_strdup(args);
1761 if (string == NULL)
1762 goto out_nomem;
1763
b979aaa1
JL		 1764 if (!cifs_convert_address(dstaddr, string,
1765 strlen(string))) {
0b456f04 1766 pr_err("CIFS: bad ip= option (%s).\n", string);
8830d7e0
SP		 1767 goto cifs_parse_mount_err;
1768 }
b979aaa1 1769 got_ip = true;
8830d7e0 1770 break;
8830d7e0
SP		 1771 case Opt_domain:
1772 string = match_strdup(args);
1773 if (string == NULL)
1774 goto out_nomem;
1775
057d6332
CG		 1776 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1777 == CIFS_MAX_DOMAINNAME_LEN) {
0b456f04 1778 pr_warn("CIFS: domain name too long\n");
8830d7e0
SP		 1779 goto cifs_parse_mount_err;
1780 }
1781
2bd50fb3 1782 kfree(vol->domainname);
8830d7e0
SP		 1783 vol->domainname = kstrdup(string, GFP_KERNEL);
1784 if (!vol->domainname) {
0b456f04 1785 pr_warn("CIFS: no memory for domainname\n");
8830d7e0
SP		 1786 goto cifs_parse_mount_err;
1787 }
f96637be 1788 cifs_dbg(FYI, "Domain name set\n");
8830d7e0
SP		 1789 break;
1790 case Opt_srcaddr:
1791 string = match_strdup(args);
1792 if (string == NULL)
1793 goto out_nomem;
1794
4fe9e963 1795 if (!cifs_convert_address(
8830d7e0
SP		 1796 (struct sockaddr *)&vol->srcaddr,
1797 string, strlen(string))) {
0b456f04
AS		 1798 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1799 string);
8830d7e0
SP		 1800 goto cifs_parse_mount_err;
1801 }
1802 break;
8830d7e0
SP		 1803 case Opt_iocharset:
1804 string = match_strdup(args);
1805 if (string == NULL)
1806 goto out_nomem;
1807
4fe9e963 1808 if (strnlen(string, 1024) >= 65) {
0b456f04 1809 pr_warn("CIFS: iocharset name too long.\n");
8830d7e0
SP		 1810 goto cifs_parse_mount_err;
1811 }
1812
87e747cd 1813 if (strncasecmp(string, "default", 7) != 0) {
2bd50fb3 1814 kfree(vol->iocharset);
8830d7e0
SP		 1815 vol->iocharset = kstrdup(string,
1816 GFP_KERNEL);
1817 if (!vol->iocharset) {
0b456f04 1818 pr_warn("CIFS: no memory for charset\n");
8830d7e0
SP		 1819 goto cifs_parse_mount_err;
1820 }
1821 }
1822 /* if iocharset not set then load_nls_default
1823 * is used by caller
1824 */
f96637be 1825 cifs_dbg(FYI, "iocharset set to %s\n", string);
8830d7e0 1826 break;
8830d7e0
SP		 1827 case Opt_netbiosname:
1828 string = match_strdup(args);
1829 if (string == NULL)
1830 goto out_nomem;
1831
8830d7e0
SP		 1832 memset(vol->source_rfc1001_name, 0x20,
1833 RFC1001_NAME_LEN);
1834 /*
1835 * FIXME: are there cases in which a comma can
1836 * be valid in workstation netbios name (and
1837 * need special handling)?
1838 */
1839 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1840 /* don't ucase netbiosname for user */
1841 if (string[i] == 0)
1842 break;
1843 vol->source_rfc1001_name[i] = string[i];
1844 }
1845 /* The string has 16th byte zero still from
1846 * set at top of the function
1847 */
1848 if (i == RFC1001_NAME_LEN && string[i] != 0)
0b456f04 1849 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
8830d7e0
SP		 1850 break;
1851 case Opt_servern:
1852 /* servernetbiosname specified override *SMBSERVER */
1853 string = match_strdup(args);
1854 if (string == NULL)
1855 goto out_nomem;
1856
8830d7e0
SP		 1857 /* last byte, type, is 0x20 for servr type */
1858 memset(vol->target_rfc1001_name, 0x20,
1859 RFC1001_NAME_LEN_WITH_NULL);
1860
1861 /* BB are there cases in which a comma can be
1862 valid in this workstation netbios name
1863 (and need special handling)? */
1864
1865 /* user or mount helper must uppercase the
1866 netbios name */
1867 for (i = 0; i < 15; i++) {
1868 if (string[i] == 0)
1869 break;
1870 vol->target_rfc1001_name[i] = string[i];
1871 }
1872 /* The string has 16th byte zero still from
1873 set at top of the function */
1874 if (i == RFC1001_NAME_LEN && string[i] != 0)
0b456f04 1875 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
8830d7e0
SP		 1876 break;
1877 case Opt_ver:
7e682f76 1878 /* version of mount userspace tools, not dialect */
8830d7e0
SP		 1879 string = match_strdup(args);
1880 if (string == NULL)
1881 goto out_nomem;
1882
7e682f76 1883 /* If interface changes in mount.cifs bump to new ver */
87e747cd 1884 if (strncasecmp(string, "1", 1) == 0) {
7e682f76
SF		 1885 if (strlen(string) > 1) {
1886 pr_warn("Bad mount helper ver=%s. Did "
1887 "you want SMB1 (CIFS) dialect "
1888 "and mean to type vers=1.0 "
1889 "instead?\n", string);
1890 goto cifs_parse_mount_err;
1891 }
8830d7e0
SP		 1892 /* This is the default */
1893 break;
1894 }
1895 /* For all other value, error */
7e682f76 1896 pr_warn("CIFS: Invalid mount helper version specified\n");
b946845a 1897 goto cifs_parse_mount_err;
23db65f5 1898 case Opt_vers:
7e682f76 1899 /* protocol version (dialect) */
23db65f5
JL		 1900 string = match_strdup(args);
1901 if (string == NULL)
1902 goto out_nomem;
1903
1904 if (cifs_parse_smb_version(string, vol) != 0)
1905 goto cifs_parse_mount_err;
7e682f76 1906 got_version = true;
23db65f5 1907 break;
8830d7e0
SP		 1908 case Opt_sec:
1909 string = match_strdup(args);
1910 if (string == NULL)
1911 goto out_nomem;
1912
8830d7e0
SP		 1913 if (cifs_parse_security_flavors(string, vol) != 0)
1914 goto cifs_parse_mount_err;
1915 break;
15b6a473
JL		 1916 case Opt_cache:
1917 string = match_strdup(args);
1918 if (string == NULL)
1919 goto out_nomem;
1920
1921 if (cifs_parse_cache_flavor(string, vol) != 0)
1922 goto cifs_parse_mount_err;
1923 break;
8830d7e0 1924 default:
d8162558
JL		 1925 /*
1926 * An option we don't recognize. Save it off for later
1927 * if we haven't already found one
1928 */
1929 if (!invalid)
1930 invalid = data;
8830d7e0 1931 break;
1da177e4 1932 }
8830d7e0
SP		 1933 /* Free up any allocated string */
1934 kfree(string);
1935 string = NULL;
1da177e4 1936 }
0eb8a132 1937
d8162558 1938 if (!sloppy && invalid) {
0b456f04 1939 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
d8162558
JL		 1940 goto cifs_parse_mount_err;
1941 }
1942
8a8798a5
JL		 1943#ifndef CONFIG_KEYS
1944 /* Muliuser mounts require CONFIG_KEYS support */
1945 if (vol->multiuser) {
f96637be 1946 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
b946845a 1947 goto cifs_parse_mount_err;
0eb8a132 1948 }
8a8798a5 1949#endif
e5e69abd 1950 if (!vol->UNC) {
37d4f99b 1951 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
e5e69abd
JL		 1952 goto cifs_parse_mount_err;
1953 }
0eb8a132 1954
62a1a439
JL		 1955 /* make sure UNC has a share name */
1956 if (!strchr(vol->UNC + 3, '\\')) {
f96637be 1957 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
62a1a439
JL		 1958 goto cifs_parse_mount_err;
1959 }
1960
b979aaa1 1961 if (!got_ip) {
29bb3158
DP		 1962 int len;
1963 const char *slash;
1964
b979aaa1 1965 /* No ip= option specified? Try to get it from UNC */
29bb3158
DP		 1966 /* Use the address part of the UNC. */
1967 slash = strchr(&vol->UNC[2], '\\');
1968 len = slash - &vol->UNC[2];
1969 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
0b456f04 1970 pr_err("Unable to determine destination address.\n");
b979aaa1
JL		 1971 goto cifs_parse_mount_err;
1972 }
1973 }
1974
1975 /* set the port that we got earlier */
1976 cifs_set_port(dstaddr, port);
1da177e4 1977
9b9d6b24
JL		 1978 if (uid_specified)
1979 vol->override_uid = override_uid;
1980 else if (override_uid == 1)
0b456f04 1981 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
9b9d6b24
JL		 1982
1983 if (gid_specified)
1984 vol->override_gid = override_gid;
1985 else if (override_gid == 1)
0b456f04 1986 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
9b9d6b24 1987
7e682f76
SF		 1988 if (got_version == false)
1989 pr_warn("No dialect specified on mount. Default has changed to "
1990 "a more secure dialect, SMB3 (vers=3.0), from CIFS "
1991 "(SMB1). To use the less secure SMB1 dialect to access "
1992 "old servers which do not support SMB3 specify vers=1.0"
1993 " on mount. For somewhat newer servers such as Windows "
1994 "7 try vers=2.1.\n");
1995
b946845a 1996 kfree(mountdata_copy);
1da177e4 1997 return 0;
b946845a 1998
8830d7e0 1999out_nomem:
0b456f04 2000 pr_warn("Could not allocate temporary buffer\n");
b946845a 2001cifs_parse_mount_err:
8830d7e0 2002 kfree(string);
b946845a
SF		 2003 kfree(mountdata_copy);
2004 return 1;
1da177e4
LT		 2005}
2006
3eb9a889
BG		 2007/** Returns true if srcaddr isn't specified and rhs isn't
2008 * specified, or if srcaddr is specified and
2009 * matches the IP address of the rhs argument.
2010 */
2011static bool
2012srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2013{
2014 switch (srcaddr->sa_family) {
2015 case AF_UNSPEC:
2016 return (rhs->sa_family == AF_UNSPEC);
2017 case AF_INET: {
2018 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2019 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2020 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2021 }
2022 case AF_INET6: {
2023 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
e3e2775c 2024 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
3eb9a889
BG		 2025 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2026 }
2027 default:
2028 WARN_ON(1);
2029 return false; /* don't expect to be here */
2030 }
2031}
2032
4b886136
PS		 2033/*
2034 * If no port is specified in addr structure, we try to match with 445 port
2035 * and if it fails - with 139 ports. It should be called only if address
2036 * families of server and addr are equal.
2037 */
2038static bool
2039match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2040{
6da97910 2041 __be16 port, *sport;
4b886136
PS		 2042
2043 switch (addr->sa_family) {
2044 case AF_INET:
2045 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2046 port = ((struct sockaddr_in *) addr)->sin_port;
2047 break;
2048 case AF_INET6:
2049 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2050 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2051 break;
2052 default:
2053 WARN_ON(1);
2054 return false;
2055 }
2056
2057 if (!port) {
2058 port = htons(CIFS_PORT);
2059 if (port == *sport)
2060 return true;
2061
2062 port = htons(RFC1001_PORT);
2063 }
2064
2065 return port == *sport;
2066}
3eb9a889 2067
4515148e 2068static bool
3eb9a889
BG		 2069match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2070 struct sockaddr *srcaddr)
4515148e 2071{
4515148e 2072 switch (addr->sa_family) {
a9f1b85e
PS		 2073 case AF_INET: {
2074 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2075 struct sockaddr_in *srv_addr4 =
2076 (struct sockaddr_in *)&server->dstaddr;
2077
2078 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
4515148e 2079 return false;
4515148e 2080 break;
a9f1b85e
PS		 2081 }
2082 case AF_INET6: {
2083 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2084 struct sockaddr_in6 *srv_addr6 =
2085 (struct sockaddr_in6 *)&server->dstaddr;
2086
4515148e 2087 if (!ipv6_addr_equal(&addr6->sin6_addr,
a9f1b85e 2088 &srv_addr6->sin6_addr))
4515148e 2089 return false;
a9f1b85e 2090 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
4515148e 2091 return false;
4515148e
JL		 2092 break;
2093 }
a9f1b85e
PS		 2094 default:
2095 WARN_ON(1);
2096 return false; /* don't expect to be here */
2097 }
4515148e 2098
3eb9a889
BG		 2099 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2100 return false;
2101
4515148e
JL		 2102 return true;
2103}
2104
daf5b0b6
JL		 2105static bool
2106match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2107{
3f618223
JL		 2108 /*
2109 * The select_sectype function should either return the vol->sectype
2110 * that was specified, or "Unspecified" if that sectype was not
2111 * compatible with the given NEGOTIATE request.
2112 */
ef65aaed
SP		 2113 if (server->ops->select_sectype(server, vol->sectype)
2114 == Unspecified)
daf5b0b6 2115 return false;
daf5b0b6 2116
3f618223
JL		 2117 /*
2118 * Now check if signing mode is acceptable. No need to check
2119 * global_secflags at this point since if MUST_SIGN is set then
2120 * the server->sign had better be too.
2121 */
38d77c50
JL		 2122 if (vol->sign && !server->sign)
2123 return false;
daf5b0b6
JL		 2124
2125 return true;
2126}
2127
9fa114f7 2128static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
37bb04e5 2129{
9fa114f7
JL		 2130 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2131
a0b3df5c
JL		 2132 if (vol->nosharesock)
2133 return 0;
2134
23db65f5
JL		 2135 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2136 return 0;
2137
37bb04e5
PS		 2138 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2139 return 0;
2140
2141 if (!match_address(server, addr,
2142 (struct sockaddr *)&vol->srcaddr))
2143 return 0;
2144
2145 if (!match_port(server, addr))
2146 return 0;
2147
2148 if (!match_security(server, vol))
2149 return 0;
2150
b782fcc1 2151 if (server->echo_interval != vol->echo_interval * HZ)
adfeb3e0
SF		 2152 return 0;
2153
37bb04e5
PS		 2154 return 1;
2155}
2156
e7ddee90 2157static struct TCP_Server_Info *
9fa114f7 2158cifs_find_tcp_session(struct smb_vol *vol)
1da177e4 2159{
e7ddee90 2160 struct TCP_Server_Info *server;
e7ddee90 2161
3f9bcca7 2162 spin_lock(&cifs_tcp_ses_lock);
4515148e 2163 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
9fa114f7 2164 if (!match_server(server, vol))
daf5b0b6
JL		 2165 continue;
2166
e7ddee90 2167 ++server->srv_count;
3f9bcca7 2168 spin_unlock(&cifs_tcp_ses_lock);
f96637be 2169 cifs_dbg(FYI, "Existing tcp session with server found\n");
e7ddee90 2170 return server;
1da177e4 2171 }
3f9bcca7 2172 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2173 return NULL;
2174}
1b20d672 2175
53e0e11e
PS		 2176void
2177cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
1da177e4 2178{
a5c3e1c7
SF		 2179 struct task_struct *task;
2180
3f9bcca7 2181 spin_lock(&cifs_tcp_ses_lock);
e7ddee90 2182 if (--server->srv_count > 0) {
3f9bcca7 2183 spin_unlock(&cifs_tcp_ses_lock);
e7ddee90 2184 return;
1da177e4 2185 }
1b20d672 2186
f1d0c998
RL		 2187 put_net(cifs_net_ns(server));
2188
e7ddee90 2189 list_del_init(&server->tcp_ses_list);
3f9bcca7 2190 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2191
c74093b6
JL		 2192 cancel_delayed_work_sync(&server->echo);
2193
53e0e11e
PS		 2194 if (from_reconnect)
2195 /*
2196 * Avoid deadlock here: reconnect work calls
2197 * cifs_put_tcp_session() at its end. Need to be sure
2198 * that reconnect work does nothing with server pointer after
2199 * that step.
2200 */
2201 cancel_delayed_work(&server->reconnect);
2202 else
2203 cancel_delayed_work_sync(&server->reconnect);
53e0e11e 2204
e7ddee90
JL		 2205 spin_lock(&GlobalMid_Lock);
2206 server->tcpStatus = CifsExiting;
2207 spin_unlock(&GlobalMid_Lock);
dea570e0 2208
026e93dc 2209 cifs_crypto_secmech_release(server);
488f1d2d
SJ		 2210 cifs_fscache_release_client_cookie(server);
2211
21e73393
SP		 2212 kfree(server->session_key.response);
2213 server->session_key.response = NULL;
2214 server->session_key.len = 0;
a5c3e1c7
SF		 2215
2216 task = xchg(&server->tsk, NULL);
2217 if (task)
2218 force_sig(SIGKILL, task);
1da177e4
LT		 2219}
2220
63c038c2
JL		 2221static struct TCP_Server_Info *
2222cifs_get_tcp_session(struct smb_vol *volume_info)
2223{
2224 struct TCP_Server_Info *tcp_ses = NULL;
63c038c2
JL		 2225 int rc;
2226
f96637be 2227 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
63c038c2
JL		 2228
2229 /* see if we already have a matching tcp_ses */
9fa114f7 2230 tcp_ses = cifs_find_tcp_session(volume_info);
63c038c2
JL		 2231 if (tcp_ses)
2232 return tcp_ses;
2233
2234 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2235 if (!tcp_ses) {
2236 rc = -ENOMEM;
2237 goto out_err;
2238 }
2239
23db65f5
JL		 2240 tcp_ses->ops = volume_info->ops;
2241 tcp_ses->vals = volume_info->vals;
f1d0c998 2242 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
63c038c2
JL		 2243 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2244 if (IS_ERR(tcp_ses->hostname)) {
2245 rc = PTR_ERR(tcp_ses->hostname);
f7c5445a 2246 goto out_err_crypto_release;
63c038c2
JL		 2247 }
2248
2249 tcp_ses->noblocksnd = volume_info->noblocksnd;
2250 tcp_ses->noautotune = volume_info->noautotune;
6a5fa236 2251 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
fc40f9cf 2252 tcp_ses->in_flight = 0;
2d86dbc9 2253 tcp_ses->credits = 1;
63c038c2
JL		 2254 init_waitqueue_head(&tcp_ses->response_q);
2255 init_waitqueue_head(&tcp_ses->request_q);
2256 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2257 mutex_init(&tcp_ses->srv_mutex);
2258 memcpy(tcp_ses->workstation_RFC1001_name,
2259 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2260 memcpy(tcp_ses->server_RFC1001_name,
2261 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
5d0d2882 2262 tcp_ses->session_estab = false;
63c038c2 2263 tcp_ses->sequence_number = 0;
fda35943 2264 tcp_ses->lstrp = jiffies;
58fa015f 2265 spin_lock_init(&tcp_ses->req_lock);
63c038c2
JL		 2266 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2267 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
c74093b6 2268 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
53e0e11e
PS		 2269 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2270 mutex_init(&tcp_ses->reconnect_mutex);
9fa114f7
JL		 2271 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2272 sizeof(tcp_ses->srcaddr));
2273 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2274 sizeof(tcp_ses->dstaddr));
fa70b87c 2275 generate_random_uuid(tcp_ses->client_guid);
63c038c2
JL		 2276 /*
2277 * at this point we are the only ones with the pointer
2278 * to the struct since the kernel thread not created yet
2279 * no need to spinlock this init of tcpStatus or srv_count
2280 */
2281 tcp_ses->tcpStatus = CifsNew;
2282 ++tcp_ses->srv_count;
2283
adfeb3e0
SF		 2284 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2285 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2286 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2287 else
2288 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2289
a9f1b85e 2290 rc = ip_connect(tcp_ses);
63c038c2 2291 if (rc < 0) {
f96637be 2292 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
f7c5445a 2293 goto out_err_crypto_release;
63c038c2
JL		 2294 }
2295
2296 /*
2297 * since we're in a cifs function already, we know that
2298 * this will succeed. No need for try_module_get().
2299 */
2300 __module_get(THIS_MODULE);
7c97c200 2301 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
63c038c2
JL		 2302 tcp_ses, "cifsd");
2303 if (IS_ERR(tcp_ses->tsk)) {
2304 rc = PTR_ERR(tcp_ses->tsk);
f96637be 2305 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
63c038c2 2306 module_put(THIS_MODULE);
f7c5445a 2307 goto out_err_crypto_release;
63c038c2 2308 }
fd88ce93 2309 tcp_ses->tcpStatus = CifsNeedNegotiate;
63c038c2
JL		 2310
2311 /* thread spawned, put it on the list */
3f9bcca7 2312 spin_lock(&cifs_tcp_ses_lock);
63c038c2 2313 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
3f9bcca7 2314 spin_unlock(&cifs_tcp_ses_lock);
63c038c2 2315
488f1d2d
SJ		 2316 cifs_fscache_get_client_cookie(tcp_ses);
2317
c74093b6 2318 /* queue echo request delayed work */
adfeb3e0 2319 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
c74093b6 2320
63c038c2
JL		 2321 return tcp_ses;
2322
f7c5445a 2323out_err_crypto_release:
026e93dc 2324 cifs_crypto_secmech_release(tcp_ses);
d2b91521 2325
f1d0c998
RL		 2326 put_net(cifs_net_ns(tcp_ses));
2327
63c038c2
JL		 2328out_err:
2329 if (tcp_ses) {
8347a5cd
SF		 2330 if (!IS_ERR(tcp_ses->hostname))
2331 kfree(tcp_ses->hostname);
63c038c2
JL		 2332 if (tcp_ses->ssocket)
2333 sock_release(tcp_ses->ssocket);
2334 kfree(tcp_ses);
2335 }
2336 return ERR_PTR(rc);
2337}
2338
96daf2b0 2339static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
37bb04e5 2340{
3f618223
JL		 2341 if (vol->sectype != Unspecified &&
2342 vol->sectype != ses->sectype)
2343 return 0;
2344
2345 switch (ses->sectype) {
37bb04e5 2346 case Kerberos:
64ed39dd 2347 if (!uid_eq(vol->cred_uid, ses->cred_uid))
37bb04e5
PS		 2348 return 0;
2349 break;
2350 default:
04febabc
JL		 2351 /* NULL username means anonymous session */
2352 if (ses->user_name == NULL) {
2353 if (!vol->nullauth)
2354 return 0;
2355 break;
2356 }
2357
37bb04e5 2358 /* anything else takes username/password */
04febabc
JL		 2359 if (strncmp(ses->user_name,
2360 vol->username ? vol->username : "",
8c3a2b4c 2361 CIFS_MAX_USERNAME_LEN))
37bb04e5 2362 return 0;
08b37d51 2363 if ((vol->username && strlen(vol->username) != 0) &&
37bb04e5
PS		 2364 ses->password != NULL &&
2365 strncmp(ses->password,
2366 vol->password ? vol->password : "",
8c3a2b4c 2367 CIFS_MAX_PASSWORD_LEN))
37bb04e5
PS		 2368 return 0;
2369 }
2370 return 1;
2371}
2372
96daf2b0 2373static struct cifs_ses *
4ff67b72 2374cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1da177e4 2375{
96daf2b0 2376 struct cifs_ses *ses;
dea570e0 2377
3f9bcca7 2378 spin_lock(&cifs_tcp_ses_lock);
4ff67b72 2379 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
7f48558e
SP		 2380 if (ses->status == CifsExiting)
2381 continue;
37bb04e5
PS		 2382 if (!match_session(ses, vol))
2383 continue;
14fbf50d 2384 ++ses->ses_count;
3f9bcca7 2385 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2386 return ses;
2387 }
3f9bcca7 2388 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2389 return NULL;
2390}
dea570e0 2391
14fbf50d 2392static void
96daf2b0 2393cifs_put_smb_ses(struct cifs_ses *ses)
14fbf50d 2394{
7f48558e 2395 unsigned int rc, xid;
14fbf50d 2396 struct TCP_Server_Info *server = ses->server;
dea570e0 2397
f96637be 2398 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
7f48558e 2399
3f9bcca7 2400 spin_lock(&cifs_tcp_ses_lock);
7f48558e
SP		 2401 if (ses->status == CifsExiting) {
2402 spin_unlock(&cifs_tcp_ses_lock);
2403 return;
2404 }
14fbf50d 2405 if (--ses->ses_count > 0) {
3f9bcca7 2406 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2407 return;
2408 }
7f48558e
SP		 2409 if (ses->status == CifsGood)
2410 ses->status = CifsExiting;
3f9bcca7 2411 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2412
7f48558e 2413 if (ses->status == CifsExiting && server->ops->logoff) {
6d5786a3 2414 xid = get_xid();
7f48558e
SP		 2415 rc = server->ops->logoff(xid, ses);
2416 if (rc)
2417 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2418 __func__, rc);
6d5786a3 2419 _free_xid(xid);
14fbf50d 2420 }
7f48558e
SP		 2421
2422 spin_lock(&cifs_tcp_ses_lock);
2423 list_del_init(&ses->smb_ses_list);
2424 spin_unlock(&cifs_tcp_ses_lock);
2425
14fbf50d 2426 sesInfoFree(ses);
53e0e11e 2427 cifs_put_tcp_session(server, 0);
14fbf50d 2428}
dea570e0 2429
8a8798a5
JL		 2430#ifdef CONFIG_KEYS
2431
057d6332
CG		 2432/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2433#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
8a8798a5
JL		 2434
2435/* Populate username and pw fields from keyring if possible */
2436static int
2437cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2438{
2439 int rc = 0;
146aa8b1
DH		 2440 const char *delim, *payload;
2441 char *desc;
8a8798a5
JL		 2442 ssize_t len;
2443 struct key *key;
2444 struct TCP_Server_Info *server = ses->server;
2445 struct sockaddr_in *sa;
2446 struct sockaddr_in6 *sa6;
146aa8b1 2447 const struct user_key_payload *upayload;
8a8798a5
JL		 2448
2449 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2450 if (!desc)
2451 return -ENOMEM;
2452
2453 /* try to find an address key first */
2454 switch (server->dstaddr.ss_family) {
2455 case AF_INET:
2456 sa = (struct sockaddr_in *)&server->dstaddr;
2457 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2458 break;
2459 case AF_INET6:
2460 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2461 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2462 break;
2463 default:
f96637be
JP		 2464 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2465 server->dstaddr.ss_family);
8a8798a5
JL		 2466 rc = -EINVAL;
2467 goto out_err;
2468 }
2469
f96637be 2470 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
8a8798a5
JL		 2471 key = request_key(&key_type_logon, desc, "");
2472 if (IS_ERR(key)) {
2473 if (!ses->domainName) {
f96637be 2474 cifs_dbg(FYI, "domainName is NULL\n");
8a8798a5
JL		 2475 rc = PTR_ERR(key);
2476 goto out_err;
2477 }
2478
2479 /* didn't work, try to find a domain key */
2480 sprintf(desc, "cifs:d:%s", ses->domainName);
f96637be 2481 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
8a8798a5
JL		 2482 key = request_key(&key_type_logon, desc, "");
2483 if (IS_ERR(key)) {
2484 rc = PTR_ERR(key);
2485 goto out_err;
2486 }
2487 }
2488
2489 down_read(&key->sem);
0837e49a 2490 upayload = user_key_payload_locked(key);
8a8798a5 2491 if (IS_ERR_OR_NULL(upayload)) {
4edc53c1 2492 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
8a8798a5
JL		 2493 goto out_key_put;
2494 }
2495
2496 /* find first : in payload */
146aa8b1 2497 payload = upayload->data;
8a8798a5 2498 delim = strnchr(payload, upayload->datalen, ':');
f96637be 2499 cifs_dbg(FYI, "payload=%s\n", payload);
8a8798a5 2500 if (!delim) {
f96637be
JP		 2501 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2502 upayload->datalen);
8a8798a5
JL		 2503 rc = -EINVAL;
2504 goto out_key_put;
2505 }
2506
2507 len = delim - payload;
8c3a2b4c 2508 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
f96637be
JP		 2509 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2510 len);
8a8798a5
JL		 2511 rc = -EINVAL;
2512 goto out_key_put;
2513 }
2514
2515 vol->username = kstrndup(payload, len, GFP_KERNEL);
2516 if (!vol->username) {
f96637be
JP		 2517 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2518 len);
8a8798a5
JL		 2519 rc = -ENOMEM;
2520 goto out_key_put;
2521 }
f96637be 2522 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
8a8798a5
JL		 2523
2524 len = key->datalen - (len + 1);
8c3a2b4c 2525 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
f96637be 2526 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
8a8798a5
JL		 2527 rc = -EINVAL;
2528 kfree(vol->username);
2529 vol->username = NULL;
2530 goto out_key_put;
2531 }
2532
2533 ++delim;
2534 vol->password = kstrndup(delim, len, GFP_KERNEL);
2535 if (!vol->password) {
f96637be
JP		 2536 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2537 len);
8a8798a5
JL		 2538 rc = -ENOMEM;
2539 kfree(vol->username);
2540 vol->username = NULL;
2541 goto out_key_put;
2542 }
2543
2544out_key_put:
2545 up_read(&key->sem);
2546 key_put(key);
2547out_err:
2548 kfree(desc);
f96637be 2549 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
8a8798a5
JL		 2550 return rc;
2551}
2552#else /* ! CONFIG_KEYS */
2553static inline int
2554cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2555 struct cifs_ses *ses __attribute__((unused)))
2556{
2557 return -ENOSYS;
2558}
2559#endif /* CONFIG_KEYS */
2560
96daf2b0 2561static struct cifs_ses *
36988c76
JL		 2562cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2563{
286170aa
PS		 2564 int rc = -ENOMEM;
2565 unsigned int xid;
96daf2b0 2566 struct cifs_ses *ses;
a9f1b85e
PS		 2567 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2568 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
36988c76 2569
6d5786a3 2570 xid = get_xid();
36988c76 2571
4ff67b72 2572 ses = cifs_find_smb_ses(server, volume_info);
36988c76 2573 if (ses) {
f96637be
JP		 2574 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2575 ses->status);
36988c76 2576
36988c76 2577 mutex_lock(&ses->session_mutex);
198b5682
JL		 2578 rc = cifs_negotiate_protocol(xid, ses);
2579 if (rc) {
2580 mutex_unlock(&ses->session_mutex);
2581 /* problem -- put our ses reference */
2582 cifs_put_smb_ses(ses);
6d5786a3 2583 free_xid(xid);
198b5682
JL		 2584 return ERR_PTR(rc);
2585 }
36988c76 2586 if (ses->need_reconnect) {
f96637be 2587 cifs_dbg(FYI, "Session needs reconnect\n");
36988c76
JL		 2588 rc = cifs_setup_session(xid, ses,
2589 volume_info->local_nls);
2590 if (rc) {
2591 mutex_unlock(&ses->session_mutex);
2592 /* problem -- put our reference */
2593 cifs_put_smb_ses(ses);
6d5786a3 2594 free_xid(xid);
36988c76
JL		 2595 return ERR_PTR(rc);
2596 }
2597 }
2598 mutex_unlock(&ses->session_mutex);
460cf341
JL		 2599
2600 /* existing SMB ses has a server reference already */
53e0e11e 2601 cifs_put_tcp_session(server, 0);
6d5786a3 2602 free_xid(xid);
36988c76
JL		 2603 return ses;
2604 }
2605
f96637be 2606 cifs_dbg(FYI, "Existing smb sess not found\n");
36988c76
JL		 2607 ses = sesInfoAlloc();
2608 if (ses == NULL)
2609 goto get_ses_fail;
2610
2611 /* new SMB session uses our server ref */
2612 ses->server = server;
a9f1b85e
PS		 2613 if (server->dstaddr.ss_family == AF_INET6)
2614 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
36988c76 2615 else
a9f1b85e 2616 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
36988c76 2617
8727c8a8
SF		 2618 if (volume_info->username) {
2619 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2620 if (!ses->user_name)
2621 goto get_ses_fail;
2622 }
36988c76
JL		 2623
2624 /* volume_info->password freed at unmount */
2625 if (volume_info->password) {
2626 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2627 if (!ses->password)
2628 goto get_ses_fail;
2629 }
2630 if (volume_info->domainname) {
d3686d54
SP		 2631 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2632 if (!ses->domainName)
2633 goto get_ses_fail;
36988c76 2634 }
39566443
GP		 2635 if (volume_info->domainauto)
2636 ses->domainAuto = volume_info->domainauto;
3e4b3e1f 2637 ses->cred_uid = volume_info->cred_uid;
36988c76 2638 ses->linux_uid = volume_info->linux_uid;
d9b94201 2639
28e11bd8
JL		 2640 ses->sectype = volume_info->sectype;
2641 ses->sign = volume_info->sign;
36988c76
JL		 2642
2643 mutex_lock(&ses->session_mutex);
198b5682
JL		 2644 rc = cifs_negotiate_protocol(xid, ses);
2645 if (!rc)
2646 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
36988c76 2647 mutex_unlock(&ses->session_mutex);
c8e56f1f 2648 if (rc)
36988c76
JL		 2649 goto get_ses_fail;
2650
2651 /* success, put it on the list */
3f9bcca7 2652 spin_lock(&cifs_tcp_ses_lock);
36988c76 2653 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3f9bcca7 2654 spin_unlock(&cifs_tcp_ses_lock);
36988c76 2655
6d5786a3 2656 free_xid(xid);
36988c76
JL		 2657 return ses;
2658
2659get_ses_fail:
2660 sesInfoFree(ses);
6d5786a3 2661 free_xid(xid);
36988c76
JL		 2662 return ERR_PTR(rc);
2663}
2664
ae6f8dd4 2665static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
37bb04e5
PS		 2666{
2667 if (tcon->tidStatus == CifsExiting)
2668 return 0;
ae6f8dd4 2669 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
37bb04e5 2670 return 0;
ae6f8dd4
PS		 2671 if (tcon->seal != volume_info->seal)
2672 return 0;
ae6f8dd4
PS		 2673 if (tcon->snapshot_time != volume_info->snapshot_time)
2674 return 0;
37bb04e5
PS		 2675 return 1;
2676}
2677
96daf2b0 2678static struct cifs_tcon *
8b217fe7 2679cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
f1987b44
JL		 2680{
2681 struct list_head *tmp;
96daf2b0 2682 struct cifs_tcon *tcon;
f1987b44 2683
3f9bcca7 2684 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2685 list_for_each(tmp, &ses->tcon_list) {
96daf2b0 2686 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
ae6f8dd4 2687 if (!match_tcon(tcon, volume_info))
f1987b44 2688 continue;
f1987b44 2689 ++tcon->tc_count;
3f9bcca7 2690 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2691 return tcon;
1da177e4 2692 }
3f9bcca7 2693 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2694 return NULL;
2695}
2696
53e0e11e 2697void
96daf2b0 2698cifs_put_tcon(struct cifs_tcon *tcon)
f1987b44 2699{
2e6e02ab 2700 unsigned int xid;
96daf2b0 2701 struct cifs_ses *ses = tcon->ses;
f1987b44 2702
f96637be 2703 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3f9bcca7 2704 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2705 if (--tcon->tc_count > 0) {
3f9bcca7 2706 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2707 return;
2708 }
2709
2710 list_del_init(&tcon->tcon_list);
3f9bcca7 2711 spin_unlock(&cifs_tcp_ses_lock);
f1987b44 2712
6d5786a3 2713 xid = get_xid();
2e6e02ab
PS		 2714 if (ses->server->ops->tree_disconnect)
2715 ses->server->ops->tree_disconnect(xid, tcon);
6d5786a3 2716 _free_xid(xid);
f1987b44 2717
d03382ce 2718 cifs_fscache_release_super_cookie(tcon);
9f841593 2719 tconInfoFree(tcon);
f1987b44
JL		 2720 cifs_put_smb_ses(ses);
2721}
2722
96daf2b0
SF		 2723static struct cifs_tcon *
2724cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
d00c28de
JL		 2725{
2726 int rc, xid;
96daf2b0 2727 struct cifs_tcon *tcon;
d00c28de 2728
8b217fe7 2729 tcon = cifs_find_tcon(ses, volume_info);
d00c28de 2730 if (tcon) {
f96637be 2731 cifs_dbg(FYI, "Found match on UNC path\n");
d00c28de
JL		 2732 /* existing tcon already has a reference */
2733 cifs_put_smb_ses(ses);
d00c28de
JL		 2734 return tcon;
2735 }
2736
2e6e02ab
PS		 2737 if (!ses->server->ops->tree_connect) {
2738 rc = -ENOSYS;
2739 goto out_fail;
2740 }
2741
d00c28de
JL		 2742 tcon = tconInfoAlloc();
2743 if (tcon == NULL) {
2744 rc = -ENOMEM;
2745 goto out_fail;
2746 }
2747
8b217fe7 2748 if (volume_info->snapshot_time) {
8b217fe7
SF		 2749 if (ses->server->vals->protocol_id == 0) {
2750 cifs_dbg(VFS,
2751 "Use SMB2 or later for snapshot mount option\n");
2752 rc = -EOPNOTSUPP;
2753 goto out_fail;
2754 } else
2755 tcon->snapshot_time = volume_info->snapshot_time;
8b217fe7
SF		 2756 }
2757
d00c28de
JL		 2758 tcon->ses = ses;
2759 if (volume_info->password) {
2760 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2761 if (!tcon->password) {
2762 rc = -ENOMEM;
2763 goto out_fail;
2764 }
2765 }
2766
2e6e02ab
PS		 2767 /*
2768 * BB Do we need to wrap session_mutex around this TCon call and Unix
2769 * SetFS as we do on SessSetup and reconnect?
2770 */
6d5786a3 2771 xid = get_xid();
2e6e02ab
PS		 2772 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2773 volume_info->local_nls);
6d5786a3 2774 free_xid(xid);
f96637be 2775 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
d00c28de
JL		 2776 if (rc)
2777 goto out_fail;
2778
2779 if (volume_info->nodfs) {
2780 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
f96637be 2781 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
d00c28de 2782 }
b618f001
SF		 2783 tcon->use_persistent = false;
2784 /* check if SMB2 or later, CIFS does not support persistent handles */
2785 if (volume_info->persistent) {
2786 if (ses->server->vals->protocol_id == 0) {
2787 cifs_dbg(VFS,
2788 "SMB3 or later required for persistent handles\n");
2789 rc = -EOPNOTSUPP;
2790 goto out_fail;
2791 } else if (ses->server->capabilities &
2792 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2793 tcon->use_persistent = true;
2794 else /* persistent handles requested but not supported */ {
2795 cifs_dbg(VFS,
2796 "Persistent handles not supported on share\n");
2797 rc = -EOPNOTSUPP;
2798 goto out_fail;
2799 }
2800 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2801 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2802 && (volume_info->nopersistent == false)) {
2803 cifs_dbg(FYI, "enabling persistent handles\n");
2804 tcon->use_persistent = true;
592fafe6
SF		 2805 } else if (volume_info->resilient) {
2806 if (ses->server->vals->protocol_id == 0) {
2807 cifs_dbg(VFS,
2808 "SMB2.1 or later required for resilient handles\n");
2809 rc = -EOPNOTSUPP;
2810 goto out_fail;
2811 }
2812 tcon->use_resilient = true;
b618f001
SF		 2813 }
2814
ae6f8dd4
PS		 2815 if (volume_info->seal) {
2816 if (ses->server->vals->protocol_id == 0) {
2817 cifs_dbg(VFS,
2818 "SMB3 or later required for encryption\n");
2819 rc = -EOPNOTSUPP;
2820 goto out_fail;
ae6f8dd4
PS		 2821 } else if (tcon->ses->server->capabilities &
2822 SMB2_GLOBAL_CAP_ENCRYPTION)
2823 tcon->seal = true;
2824 else {
2825 cifs_dbg(VFS, "Encryption is not supported on share\n");
2826 rc = -EOPNOTSUPP;
2827 goto out_fail;
ae6f8dd4
PS		 2828 }
2829 }
2830
2e6e02ab
PS		 2831 /*
2832 * We can have only one retry value for a connection to a share so for
2833 * resources mounted more than once to the same server share the last
2834 * value passed in for the retry flag is used.
2835 */
d00c28de
JL		 2836 tcon->retry = volume_info->retry;
2837 tcon->nocase = volume_info->nocase;
2838 tcon->local_lease = volume_info->local_lease;
233839b1 2839 INIT_LIST_HEAD(&tcon->pending_opens);
d00c28de 2840
3f9bcca7 2841 spin_lock(&cifs_tcp_ses_lock);
d00c28de 2842 list_add(&tcon->tcon_list, &ses->tcon_list);
3f9bcca7 2843 spin_unlock(&cifs_tcp_ses_lock);
d00c28de 2844
d03382ce
SJ		 2845 cifs_fscache_get_super_cookie(tcon);
2846
d00c28de
JL		 2847 return tcon;
2848
2849out_fail:
2850 tconInfoFree(tcon);
2851 return ERR_PTR(rc);
2852}
2853
9d002df4
JL		 2854void
2855cifs_put_tlink(struct tcon_link *tlink)
2856{
2857 if (!tlink || IS_ERR(tlink))
2858 return;
2859
2860 if (!atomic_dec_and_test(&tlink->tl_count) ||
2861 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2862 tlink->tl_time = jiffies;
2863 return;
2864 }
2865
2866 if (!IS_ERR(tlink_tcon(tlink)))
2867 cifs_put_tcon(tlink_tcon(tlink));
2868 kfree(tlink);
2869 return;
2870}
d00c28de 2871
25c7f41e 2872static inline struct tcon_link *
cd51875d
PS		 2873cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2874{
2875 return cifs_sb->master_tlink;
2876}
25c7f41e
PS		 2877
2878static int
2879compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2880{
2881 struct cifs_sb_info *old = CIFS_SB(sb);
2882 struct cifs_sb_info *new = mnt_data->cifs_sb;
2883
2884 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2885 return 0;
2886
2887 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2888 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2889 return 0;
2890
25c7f41e 2891 /*
5eba8ab3
JL		 2892 * We want to share sb only if we don't specify an r/wsize or
2893 * specified r/wsize is greater than or equal to existing one.
25c7f41e
PS		 2894 */
2895 if (new->wsize && new->wsize < old->wsize)
2896 return 0;
2897
5eba8ab3
JL		 2898 if (new->rsize && new->rsize < old->rsize)
2899 return 0;
2900
1f68233c 2901 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
25c7f41e
PS		 2902 return 0;
2903
2904 if (old->mnt_file_mode != new->mnt_file_mode ||
2905 old->mnt_dir_mode != new->mnt_dir_mode)
2906 return 0;
2907
2908 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2909 return 0;
2910
2911 if (old->actimeo != new->actimeo)
2912 return 0;
2913
2914 return 1;
2915}
2916
c1d8b24d
SP		 2917static int
2918match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2919{
2920 struct cifs_sb_info *old = CIFS_SB(sb);
2921 struct cifs_sb_info *new = mnt_data->cifs_sb;
cd8c4296
SP		 2922 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
2923 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
c1d8b24d 2924
cd8c4296 2925 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
c1d8b24d 2926 return 1;
cd8c4296
SP		 2927 else if (!old_set && !new_set)
2928 return 1;
2929
c1d8b24d
SP		 2930 return 0;
2931}
2932
25c7f41e
PS		 2933int
2934cifs_match_super(struct super_block *sb, void *data)
2935{
2936 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2937 struct smb_vol *volume_info;
2938 struct cifs_sb_info *cifs_sb;
2939 struct TCP_Server_Info *tcp_srv;
96daf2b0
SF		 2940 struct cifs_ses *ses;
2941 struct cifs_tcon *tcon;
25c7f41e 2942 struct tcon_link *tlink;
25c7f41e
PS		 2943 int rc = 0;
2944
25c7f41e
PS		 2945 spin_lock(&cifs_tcp_ses_lock);
2946 cifs_sb = CIFS_SB(sb);
2947 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2948 if (IS_ERR(tlink)) {
2949 spin_unlock(&cifs_tcp_ses_lock);
2950 return rc;
2951 }
2952 tcon = tlink_tcon(tlink);
2953 ses = tcon->ses;
2954 tcp_srv = ses->server;
2955
2956 volume_info = mnt_data->vol;
2957
9fa114f7 2958 if (!match_server(tcp_srv, volume_info) ||
25c7f41e 2959 !match_session(ses, volume_info) ||
ae6f8dd4 2960 !match_tcon(tcon, volume_info) ||
c1d8b24d 2961 !match_prepath(sb, mnt_data)) {
25c7f41e
PS		 2962 rc = 0;
2963 goto out;
2964 }
2965
2966 rc = compare_mount_options(sb, mnt_data);
2967out:
25c7f41e 2968 spin_unlock(&cifs_tcp_ses_lock);
f484b5d0 2969 cifs_put_tlink(tlink);
25c7f41e
PS		 2970 return rc;
2971}
2972
1da177e4 2973int
b669f33c 2974get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2e6e02ab
PS		 2975 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2976 struct dfs_info3_param **referrals, int remap)
1da177e4
LT		 2977{
2978 char *temp_unc;
2979 int rc = 0;
2980
b669f33c 2981 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2e6e02ab
PS		 2982 return -ENOSYS;
2983
2984 *num_referrals = 0;
2985 *referrals = NULL;
1da177e4 2986
2e6e02ab 2987 if (ses->ipc_tid == 0) {
1da177e4 2988 temp_unc = kmalloc(2 /* for slashes */ +
2e6e02ab
PS		 2989 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2990 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
1da177e4
LT		 2991 if (temp_unc == NULL)
2992 return -ENOMEM;
2993 temp_unc[0] = '\\';
2994 temp_unc[1] = '\\';
2e6e02ab
PS		 2995 strcpy(temp_unc + 2, ses->serverName);
2996 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2997 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2998 nls_codepage);
f96637be 2999 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
1da177e4
LT		 3000 kfree(temp_unc);
3001 }
3002 if (rc == 0)
b669f33c
PS		 3003 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
3004 referrals, num_referrals,
3005 nls_codepage, remap);
2e6e02ab
PS		 3006 /*
3007 * BB - map targetUNCs to dfs_info3 structures, here or in
b669f33c 3008 * ses->server->ops->get_dfs_refer.
2e6e02ab 3009 */
1da177e4
LT		 3010
3011 return rc;
3012}
3013
09e50d55
JL		 3014#ifdef CONFIG_DEBUG_LOCK_ALLOC
3015static struct lock_class_key cifs_key[2];
3016static struct lock_class_key cifs_slock_key[2];
3017
3018static inline void
3019cifs_reclassify_socket4(struct socket *sock)
3020{
3021 struct sock *sk = sock->sk;
fafc4e1e 3022 BUG_ON(!sock_allow_reclassification(sk));
09e50d55
JL		 3023 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3024 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3025}
3026
3027static inline void
3028cifs_reclassify_socket6(struct socket *sock)
3029{
3030 struct sock *sk = sock->sk;
fafc4e1e 3031 BUG_ON(!sock_allow_reclassification(sk));
09e50d55
JL		 3032 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3033 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3034}
3035#else
3036static inline void
3037cifs_reclassify_socket4(struct socket *sock)
3038{
3039}
3040
3041static inline void
3042cifs_reclassify_socket6(struct socket *sock)
3043{
3044}
3045#endif
3046
1da177e4 3047/* See RFC1001 section 14 on representation of Netbios names */
50c2f753 3048static void rfc1002mangle(char *target, char *source, unsigned int length)
1da177e4 3049{
50c2f753 3050 unsigned int i, j;
1da177e4 3051
50c2f753 3052 for (i = 0, j = 0; i < (length); i++) {
1da177e4
LT		 3053 /* mask a nibble at a time and encode */
3054 target[j] = 'A' + (0x0F & (source[i] >> 4));
3055 target[j+1] = 'A' + (0x0F & source[i]);
50c2f753 3056 j += 2;
1da177e4
LT		 3057 }
3058
3059}
3060
3eb9a889
BG		 3061static int
3062bind_socket(struct TCP_Server_Info *server)
3063{
3064 int rc = 0;
3065 if (server->srcaddr.ss_family != AF_UNSPEC) {
3066 /* Bind to the specified local IP address */
3067 struct socket *socket = server->ssocket;
3068 rc = socket->ops->bind(socket,
3069 (struct sockaddr *) &server->srcaddr,
3070 sizeof(server->srcaddr));
3071 if (rc < 0) {
3072 struct sockaddr_in *saddr4;
3073 struct sockaddr_in6 *saddr6;
3074 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3075 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3076 if (saddr6->sin6_family == AF_INET6)
f96637be
JP		 3077 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3078 &saddr6->sin6_addr, rc);
3eb9a889 3079 else
f96637be
JP		 3080 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3081 &saddr4->sin_addr.s_addr, rc);
3eb9a889
BG		 3082 }
3083 }
3084 return rc;
3085}
1da177e4
LT		 3086
3087static int
a9f1b85e 3088ip_rfc1001_connect(struct TCP_Server_Info *server)
1da177e4
LT		 3089{
3090 int rc = 0;
a9f1b85e
PS		 3091 /*
3092 * some servers require RFC1001 sessinit before sending
3093 * negprot - BB check reconnection in case where second
3094 * sessinit is sent but no second negprot
3095 */
3096 struct rfc1002_session_packet *ses_init_buf;
3097 struct smb_hdr *smb_buf;
3098 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3099 GFP_KERNEL);
3100 if (ses_init_buf) {
3101 ses_init_buf->trailer.session_req.called_len = 32;
3102
997152f6 3103 if (server->server_RFC1001_name[0] != 0)
a9f1b85e
PS		 3104 rfc1002mangle(ses_init_buf->trailer.
3105 session_req.called_name,
3106 server->server_RFC1001_name,
3107 RFC1001_NAME_LEN_WITH_NULL);
3108 else
3109 rfc1002mangle(ses_init_buf->trailer.
3110 session_req.called_name,
3111 DEFAULT_CIFS_CALLED_NAME,
3112 RFC1001_NAME_LEN_WITH_NULL);
3113
3114 ses_init_buf->trailer.session_req.calling_len = 32;
3115
3116 /*
3117 * calling name ends in null (byte 16) from old smb
3118 * convention.
3119 */
c85c35f8 3120 if (server->workstation_RFC1001_name[0] != 0)
a9f1b85e
PS		 3121 rfc1002mangle(ses_init_buf->trailer.
3122 session_req.calling_name,
3123 server->workstation_RFC1001_name,
3124 RFC1001_NAME_LEN_WITH_NULL);
3125 else
3126 rfc1002mangle(ses_init_buf->trailer.
3127 session_req.calling_name,
3128 "LINUX_CIFS_CLNT",
3129 RFC1001_NAME_LEN_WITH_NULL);
3130
3131 ses_init_buf->trailer.session_req.scope1 = 0;
3132 ses_init_buf->trailer.session_req.scope2 = 0;
3133 smb_buf = (struct smb_hdr *)ses_init_buf;
3134
3135 /* sizeof RFC1002_SESSION_REQUEST with no scope */
be8e3b00 3136 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
a9f1b85e
PS		 3137 rc = smb_send(server, smb_buf, 0x44);
3138 kfree(ses_init_buf);
3139 /*
3140 * RFC1001 layer in at least one server
3141 * requires very short break before negprot
3142 * presumably because not expecting negprot
3143 * to follow so fast. This is a simple
3144 * solution that works without
3145 * complicating the code and causes no
3146 * significant slowing down on mount
3147 * for everyone else
3148 */
3149 usleep_range(1000, 2000);
3150 }
3151 /*
3152 * else the negprot may still work without this
3153 * even though malloc failed
3154 */
3155
3156 return rc;
3157}
3158
3159static int
3160generic_ip_connect(struct TCP_Server_Info *server)
3161{
3162 int rc = 0;
6da97910 3163 __be16 sport;
a9f1b85e 3164 int slen, sfamily;
bcf4b106 3165 struct socket *socket = server->ssocket;
a9f1b85e
PS		 3166 struct sockaddr *saddr;
3167
3168 saddr = (struct sockaddr *) &server->dstaddr;
3169
3170 if (server->dstaddr.ss_family == AF_INET6) {
3171 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3172 slen = sizeof(struct sockaddr_in6);
3173 sfamily = AF_INET6;
3174 } else {
3175 sport = ((struct sockaddr_in *) saddr)->sin_port;
3176 slen = sizeof(struct sockaddr_in);
3177 sfamily = AF_INET;
3178 }
1da177e4 3179
bcf4b106 3180 if (socket == NULL) {
f1d0c998
RL		 3181 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3182 IPPROTO_TCP, &socket, 1);
1da177e4 3183 if (rc < 0) {
f96637be 3184 cifs_dbg(VFS, "Error %d creating socket\n", rc);
a9f1b85e 3185 server->ssocket = NULL;
1da177e4 3186 return rc;
1da177e4 3187 }
bcf4b106
JL		 3188
3189 /* BB other socket options to set KEEPALIVE, NODELAY? */
f96637be 3190 cifs_dbg(FYI, "Socket created\n");
bcf4b106
JL		 3191 server->ssocket = socket;
3192 socket->sk->sk_allocation = GFP_NOFS;
a9f1b85e
PS		 3193 if (sfamily == AF_INET6)
3194 cifs_reclassify_socket6(socket);
3195 else
3196 cifs_reclassify_socket4(socket);
1da177e4
LT		 3197 }
3198
3eb9a889
BG		 3199 rc = bind_socket(server);
3200 if (rc < 0)
3201 return rc;
3202
bcf4b106
JL		 3203 /*
3204 * Eventually check for other socket options to change from
a9f1b85e
PS		 3205 * the default. sock_setsockopt not used because it expects
3206 * user space buffer
bcf4b106
JL		 3207 */
3208 socket->sk->sk_rcvtimeo = 7 * HZ;
da505c38 3209 socket->sk->sk_sndtimeo = 5 * HZ;
edf1ae40 3210
b387eaeb 3211 /* make the bufsizes depend on wsize/rsize and max requests */
bcf4b106
JL		 3212 if (server->noautotune) {
3213 if (socket->sk->sk_sndbuf < (200 * 1024))
3214 socket->sk->sk_sndbuf = 200 * 1024;
3215 if (socket->sk->sk_rcvbuf < (140 * 1024))
3216 socket->sk->sk_rcvbuf = 140 * 1024;
edf1ae40 3217 }
1da177e4 3218
6a5fa236 3219 if (server->tcp_nodelay) {
a9f1b85e 3220 int val = 1;
6a5fa236
SF		 3221 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3222 (char *)&val, sizeof(val));
3223 if (rc)
f96637be
JP		 3224 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3225 rc);
6a5fa236
SF		 3226 }
3227
f96637be 3228 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
bcf4b106 3229 socket->sk->sk_sndbuf,
b6b38f70 3230 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
bcf4b106 3231
ee1b3ea9
JL		 3232 rc = socket->ops->connect(socket, saddr, slen, 0);
3233 if (rc < 0) {
f96637be 3234 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
ee1b3ea9
JL		 3235 sock_release(socket);
3236 server->ssocket = NULL;
3237 return rc;
3238 }
3239
a9f1b85e
PS		 3240 if (sport == htons(RFC1001_PORT))
3241 rc = ip_rfc1001_connect(server);
50c2f753 3242
1da177e4
LT		 3243 return rc;
3244}
3245
3246static int
a9f1b85e 3247ip_connect(struct TCP_Server_Info *server)
1da177e4 3248{
6da97910 3249 __be16 *sport;
a9f1b85e
PS		 3250 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3251 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1da177e4 3252
a9f1b85e
PS		 3253 if (server->dstaddr.ss_family == AF_INET6)
3254 sport = &addr6->sin6_port;
3255 else
3256 sport = &addr->sin_port;
1da177e4 3257
a9f1b85e
PS		 3258 if (*sport == 0) {
3259 int rc;
1da177e4 3260
a9f1b85e
PS		 3261 /* try with 445 port at first */
3262 *sport = htons(CIFS_PORT);
3eb9a889 3263
a9f1b85e 3264 rc = generic_ip_connect(server);
1da177e4 3265 if (rc >= 0)
a9f1b85e 3266 return rc;
6a5fa236 3267
a9f1b85e
PS		 3268 /* if it failed, try with 139 port */
3269 *sport = htons(RFC1001_PORT);
6a5fa236
SF		 3270 }
3271
a9f1b85e 3272 return generic_ip_connect(server);
1da177e4
LT		 3273}
3274
6d5786a3 3275void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2c6292ae 3276 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
8af18971
SF		 3277{
3278 /* if we are reconnecting then should we check to see if
3279 * any requested capabilities changed locally e.g. via
3280 * remount but we can not do much about it here
3281 * if they have (even if we could detect it by the following)
3282 * Perhaps we could add a backpointer to array of sb from tcon
3283 * or if we change to make all sb to same share the same
3284 * sb as NFS - then we only have one backpointer to sb.
3285 * What if we wanted to mount the server share twice once with
3286 * and once without posixacls or posix paths? */
3287 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
50c2f753 3288
c18c842b
SF		 3289 if (vol_info && vol_info->no_linux_ext) {
3290 tcon->fsUnixInfo.Capability = 0;
3291 tcon->unix_ext = 0; /* Unix Extensions disabled */
f96637be 3292 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
c18c842b
SF		 3293 return;
3294 } else if (vol_info)
3295 tcon->unix_ext = 1; /* Unix Extensions supported */
3296
3297 if (tcon->unix_ext == 0) {
f96637be 3298 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
c18c842b
SF		 3299 return;
3300 }
50c2f753 3301
fb8c4b14 3302 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
8af18971 3303 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
f96637be 3304 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
8af18971
SF		 3305 /* check for reconnect case in which we do not
3306 want to change the mount behavior if we can avoid it */
fb8c4b14 3307 if (vol_info == NULL) {
50c2f753 3308 /* turn off POSIX ACL and PATHNAMES if not set
8af18971
SF		 3309 originally at mount time */
3310 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3311 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
11b6d645
IM		 3312 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3313 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
f96637be 3314 cifs_dbg(VFS, "POSIXPATH support change\n");
8af18971 3315 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
11b6d645 3316 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
f96637be
JP		 3317 cifs_dbg(VFS, "possible reconnect error\n");
3318 cifs_dbg(VFS, "server disabled POSIX path support\n");
11b6d645 3319 }
8af18971 3320 }
50c2f753 3321
6848b733 3322 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
f96637be 3323 cifs_dbg(VFS, "per-share encryption not supported yet\n");
6848b733 3324
8af18971 3325 cap &= CIFS_UNIX_CAP_MASK;
75865f8c 3326 if (vol_info && vol_info->no_psx_acl)
8af18971 3327 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
75865f8c 3328 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
f96637be 3329 cifs_dbg(FYI, "negotiated posix acl support\n");
2c6292ae
AV		 3330 if (cifs_sb)
3331 cifs_sb->mnt_cifs_flags |=
3332 CIFS_MOUNT_POSIXACL;
8af18971
SF		 3333 }
3334
75865f8c 3335 if (vol_info && vol_info->posix_paths == 0)
8af18971 3336 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
75865f8c 3337 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
f96637be 3338 cifs_dbg(FYI, "negotiate posix pathnames\n");
2c6292ae
AV		 3339 if (cifs_sb)
3340 cifs_sb->mnt_cifs_flags |=
8af18971
SF		 3341 CIFS_MOUNT_POSIX_PATHS;
3342 }
50c2f753 3343
f96637be 3344 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
8af18971 3345#ifdef CONFIG_CIFS_DEBUG2
75865f8c 3346 if (cap & CIFS_UNIX_FCNTL_CAP)
f96637be 3347 cifs_dbg(FYI, "FCNTL cap\n");
75865f8c 3348 if (cap & CIFS_UNIX_EXTATTR_CAP)
f96637be 3349 cifs_dbg(FYI, "EXTATTR cap\n");
75865f8c 3350 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
f96637be 3351 cifs_dbg(FYI, "POSIX path cap\n");
75865f8c 3352 if (cap & CIFS_UNIX_XATTR_CAP)
f96637be 3353 cifs_dbg(FYI, "XATTR cap\n");
75865f8c 3354 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
f96637be 3355 cifs_dbg(FYI, "POSIX ACL cap\n");
75865f8c 3356 if (cap & CIFS_UNIX_LARGE_READ_CAP)
f96637be 3357 cifs_dbg(FYI, "very large read cap\n");
75865f8c 3358 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
f96637be 3359 cifs_dbg(FYI, "very large write cap\n");
6848b733 3360 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
f96637be 3361 cifs_dbg(FYI, "transport encryption cap\n");
6848b733 3362 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
f96637be 3363 cifs_dbg(FYI, "mandatory transport encryption cap\n");
8af18971
SF		 3364#endif /* CIFS_DEBUG2 */
3365 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
442aa310 3366 if (vol_info == NULL) {
f96637be 3367 cifs_dbg(FYI, "resetting capabilities failed\n");
442aa310 3368 } else
f96637be 3369 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");
5a44b319 3370
8af18971
SF		 3371 }
3372 }
3373}
3374
4214ebf4 3375int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
724d9f1c 3376 struct cifs_sb_info *cifs_sb)
b1c8d2b4 3377{
2de970ff
JL		 3378 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3379
2ced6f69
AV		 3380 spin_lock_init(&cifs_sb->tlink_tree_lock);
3381 cifs_sb->tlink_tree = RB_ROOT;
3382
25c7f41e 3383 /*
5eba8ab3
JL		 3384 * Temporarily set r/wsize for matching superblock. If we end up using
3385 * new sb then client will later negotiate it downward if needed.
25c7f41e 3386 */
5eba8ab3 3387 cifs_sb->rsize = pvolume_info->rsize;
25c7f41e
PS		 3388 cifs_sb->wsize = pvolume_info->wsize;
3389
3b795210
SF		 3390 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3391 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3392 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3393 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
f96637be
JP		 3394 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3395 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3b795210 3396
6d20e840 3397 cifs_sb->actimeo = pvolume_info->actimeo;
724d9f1c 3398 cifs_sb->local_nls = pvolume_info->local_nls;
6d20e840 3399
3b795210
SF		 3400 if (pvolume_info->noperm)
3401 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3402 if (pvolume_info->setuids)
3403 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
95932655
SF		 3404 if (pvolume_info->setuidfromacl)
3405 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3b795210
SF		 3406 if (pvolume_info->server_ino)
3407 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3408 if (pvolume_info->remap)
2baa2682
SF		 3409 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3410 if (pvolume_info->sfu_remap)
3b795210
SF		 3411 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3412 if (pvolume_info->no_xattr)
3413 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3414 if (pvolume_info->sfu_emul)
3415 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3416 if (pvolume_info->nobrl)
3417 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
be652445 3418 if (pvolume_info->nostrictsync)
4717bed6 3419 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
13a6e42a
SF		 3420 if (pvolume_info->mand_lock)
3421 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
d4ffff1f
PS		 3422 if (pvolume_info->rwpidforward)
3423 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3b795210
SF		 3424 if (pvolume_info->cifs_acl)
3425 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3c7c87fd 3426 if (pvolume_info->backupuid_specified) {
3d3ea8e6 3427 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3c7c87fd
SP		 3428 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3429 }
3430 if (pvolume_info->backupgid_specified) {
3d3ea8e6 3431 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3c7c87fd
SP		 3432 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3433 }
3b795210
SF		 3434 if (pvolume_info->override_uid)
3435 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3436 if (pvolume_info->override_gid)
3437 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3438 if (pvolume_info->dynperm)
3439 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
fa1df75d
SJ		 3440 if (pvolume_info->fsc)
3441 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
0eb8a132
JL		 3442 if (pvolume_info->multiuser)
3443 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3444 CIFS_MOUNT_NO_PERM);
d39454ff
PS		 3445 if (pvolume_info->strict_io)
3446 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3b795210 3447 if (pvolume_info->direct_io) {
f96637be 3448 cifs_dbg(FYI, "mounting share using direct i/o\n");
3b795210
SF		 3449 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3450 }
736a3320
SM		 3451 if (pvolume_info->mfsymlinks) {
3452 if (pvolume_info->sfu_emul) {
db8b631d
SF		 3453 /*
3454 * Our SFU ("Services for Unix" emulation does not allow
3455 * creating symlinks but does allow reading existing SFU
3456 * symlinks (it does allow both creating and reading SFU
3457 * style mknod and FIFOs though). When "mfsymlinks" and
3458 * "sfu" are both enabled at the same time, it allows
3459 * reading both types of symlinks, but will only create
3460 * them with mfsymlinks format. This allows better
3461 * Apple compatibility (probably better for Samba too)
3462 * while still recognizing old Windows style symlinks.
3463 */
3464 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
736a3320 3465 }
db8b631d 3466 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
736a3320 3467 }
3b795210
SF		 3468
3469 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
f96637be 3470 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4214ebf4
SP		 3471
3472 if (pvolume_info->prepath) {
3473 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3474 if (cifs_sb->prepath == NULL)
3475 return -ENOMEM;
3476 }
3477
3478 return 0;
b1c8d2b4
JL		 3479}
3480
b9bce2e9
JL		 3481static void
3482cleanup_volume_info_contents(struct smb_vol *volume_info)
1bfe73c2 3483{
b946845a 3484 kfree(volume_info->username);
1bfe73c2 3485 kzfree(volume_info->password);
95c75454 3486 kfree(volume_info->UNC);
b946845a
SF		 3487 kfree(volume_info->domainname);
3488 kfree(volume_info->iocharset);
1bfe73c2 3489 kfree(volume_info->prepath);
b9bce2e9
JL		 3490}
3491
3492void
3493cifs_cleanup_volume_info(struct smb_vol *volume_info)
3494{
3495 if (!volume_info)
3496 return;
3497 cleanup_volume_info_contents(volume_info);
1bfe73c2 3498 kfree(volume_info);
1bfe73c2
IM		 3499}
3500
b9bce2e9 3501
2d6d589d 3502#ifdef CONFIG_CIFS_DFS_UPCALL
6d3ea7e4
SF		 3503/*
3504 * cifs_build_path_to_root returns full path to root when we do not have an
3505 * exiting connection (tcon)
3506 */
1bfe73c2 3507static char *
b2a0fa15 3508build_unc_path_to_root(const struct smb_vol *vol,
1bfe73c2
IM		 3509 const struct cifs_sb_info *cifs_sb)
3510{
b2a0fa15 3511 char *full_path, *pos;
839db3d1 3512 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
b2a0fa15 3513 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
1bfe73c2 3514
b2a0fa15 3515 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
1bfe73c2
IM		 3516 if (full_path == NULL)
3517 return ERR_PTR(-ENOMEM);
3518
b2a0fa15
JL		 3519 strncpy(full_path, vol->UNC, unc_len);
3520 pos = full_path + unc_len;
3521
3522 if (pplen) {
1fc29bac
JL		 3523 *pos = CIFS_DIR_SEP(cifs_sb);
3524 strncpy(pos + 1, vol->prepath, pplen);
b2a0fa15
JL		 3525 pos += pplen;
3526 }
3527
3528 *pos = '\0'; /* add trailing null */
f87d39d9 3529 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
f96637be 3530 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
1bfe73c2
IM		 3531 return full_path;
3532}
dd613945
SF		 3533
3534/*
3535 * Perform a dfs referral query for a share and (optionally) prefix
3536 *
046462ab
SF		 3537 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3538 * to a string containing updated options for the submount. Otherwise it
3539 * will be left untouched.
dd613945
SF		 3540 *
3541 * Returns the rc from get_dfs_path to the caller, which can be used to
3542 * determine whether there were referrals.
3543 */
3544static int
b669f33c 3545expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
dd613945 3546 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
046462ab 3547 int check_prefix)
dd613945
SF		 3548{
3549 int rc;
3550 unsigned int num_referrals = 0;
3551 struct dfs_info3_param *referrals = NULL;
3552 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3553
3554 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3555 if (IS_ERR(full_path))
3556 return PTR_ERR(full_path);
3557
3558 /* For DFS paths, skip the first '\' of the UNC */
3559 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3560
b669f33c 3561 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
2baa2682 3562 &num_referrals, &referrals, cifs_remap(cifs_sb));
dd613945
SF		 3563
3564 if (!rc && num_referrals > 0) {
3565 char *fake_devname = NULL;
3566
3567 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3568 full_path + 1, referrals,
3569 &fake_devname);
3570
3571 free_dfs_info_array(referrals, num_referrals);
046462ab 3572
dd613945
SF		 3573 if (IS_ERR(mdata)) {
3574 rc = PTR_ERR(mdata);
3575 mdata = NULL;
b9bce2e9
JL		 3576 } else {
3577 cleanup_volume_info_contents(volume_info);
b9bce2e9
JL		 3578 rc = cifs_setup_volume_info(volume_info, mdata,
3579 fake_devname);
dd613945 3580 }
b9bce2e9
JL		 3581 kfree(fake_devname);
3582 kfree(cifs_sb->mountdata);
046462ab 3583 cifs_sb->mountdata = mdata;
dd613945
SF		 3584 }
3585 kfree(full_path);
3586 return rc;
3587}
2d6d589d 3588#endif
1bfe73c2 3589
04db79b0
JL		 3590static int
3591cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3592 const char *devname)
1da177e4 3593{
724d9f1c 3594 int rc = 0;
1da177e4 3595
04db79b0
JL		 3596 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3597 return -EINVAL;
1da177e4 3598
7586b765 3599 if (volume_info->nullauth) {
f96637be 3600 cifs_dbg(FYI, "Anonymous login\n");
04febabc
JL		 3601 kfree(volume_info->username);
3602 volume_info->username = NULL;
7586b765 3603 } else if (volume_info->username) {
1da177e4 3604 /* BB fixme parse for domain name here */
f96637be 3605 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
1da177e4 3606 } else {
f96637be 3607 cifs_dbg(VFS, "No username specified\n");
50c2f753
SF		 3608 /* In userspace mount helper we can get user name from alternate
3609 locations such as env variables and files on disk */
04db79b0 3610 return -EINVAL;
1da177e4
LT		 3611 }
3612
1da177e4 3613 /* this is needed for ASCII cp to Unicode converts */
7586b765 3614 if (volume_info->iocharset == NULL) {
a5fc4ce0
JL		 3615 /* load_nls_default cannot return null */
3616 volume_info->local_nls = load_nls_default();
1da177e4 3617 } else {
a5fc4ce0
JL		 3618 volume_info->local_nls = load_nls(volume_info->iocharset);
3619 if (volume_info->local_nls == NULL) {
f96637be 3620 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
b6b38f70 3621 volume_info->iocharset);
04db79b0 3622 return -ELIBACC;
1da177e4
LT		 3623 }
3624 }
724d9f1c 3625
724d9f1c
PS		 3626 return rc;
3627}
3628
04db79b0
JL		 3629struct smb_vol *
3630cifs_get_volume_info(char *mount_data, const char *devname)
3631{
3632 int rc;
3633 struct smb_vol *volume_info;
3634
6ee9542a 3635 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
04db79b0
JL		 3636 if (!volume_info)
3637 return ERR_PTR(-ENOMEM);
3638
3639 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3640 if (rc) {
3641 cifs_cleanup_volume_info(volume_info);
3642 volume_info = ERR_PTR(rc);
3643 }
3644
3645 return volume_info;
3646}
3647
a6b5058f
AA		 3648static int
3649cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3650 unsigned int xid,
3651 struct cifs_tcon *tcon,
3652 struct cifs_sb_info *cifs_sb,
3653 char *full_path)
3654{
3655 int rc;
3656 char *s;
3657 char sep, tmp;
3658
3659 sep = CIFS_DIR_SEP(cifs_sb);
3660 s = full_path;
3661
3662 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3663 while (rc == 0) {
3664 /* skip separators */
3665 while (*s == sep)
3666 s++;
3667 if (!*s)
3668 break;
3669 /* next separator */
3670 while (*s && *s != sep)
3671 s++;
3672
3673 /*
3674 * temporarily null-terminate the path at the end of
3675 * the current component
3676 */
3677 tmp = *s;
3678 *s = 0;
3679 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3680 full_path);
3681 *s = tmp;
3682 }
3683 return rc;
3684}
3685
724d9f1c 3686int
2c6292ae 3687cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
724d9f1c 3688{
1daaae8f 3689 int rc;
6d5786a3 3690 unsigned int xid;
af4281dc 3691 struct cifs_ses *ses;
96daf2b0 3692 struct cifs_tcon *tcon;
af4281dc 3693 struct TCP_Server_Info *server;
724d9f1c
PS		 3694 char *full_path;
3695 struct tcon_link *tlink;
3696#ifdef CONFIG_CIFS_DFS_UPCALL
3697 int referral_walks_count = 0;
20547490 3698#endif
dd854466 3699
20547490 3700#ifdef CONFIG_CIFS_DFS_UPCALL
724d9f1c
PS		 3701try_mount_again:
3702 /* cleanup activities if we're chasing a referral */
3703 if (referral_walks_count) {
3704 if (tcon)
3705 cifs_put_tcon(tcon);
af4281dc
PS		 3706 else if (ses)
3707 cifs_put_smb_ses(ses);
724d9f1c 3708
1dfd18d0
SP		 3709 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3710
6d5786a3 3711 free_xid(xid);
724d9f1c
PS		 3712 }
3713#endif
1daaae8f 3714 rc = 0;
724d9f1c 3715 tcon = NULL;
af4281dc
PS		 3716 ses = NULL;
3717 server = NULL;
724d9f1c
PS		 3718 full_path = NULL;
3719 tlink = NULL;
3720
6d5786a3 3721 xid = get_xid();
1da177e4 3722
63c038c2 3723 /* get a reference to a tcp session */
af4281dc
PS		 3724 server = cifs_get_tcp_session(volume_info);
3725 if (IS_ERR(server)) {
3726 rc = PTR_ERR(server);
63c038c2 3727 goto out;
1da177e4 3728 }
141891f4
SF		 3729 if ((volume_info->max_credits < 20) ||
3730 (volume_info->max_credits > 60000))
3731 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3732 else
3733 server->max_credits = volume_info->max_credits;
36988c76 3734 /* get a reference to a SMB session */
af4281dc
PS		 3735 ses = cifs_get_smb_ses(server, volume_info);
3736 if (IS_ERR(ses)) {
3737 rc = PTR_ERR(ses);
3738 ses = NULL;
36988c76 3739 goto mount_fail_check;
1da177e4 3740 }
50c2f753 3741
b618f001
SF		 3742 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3743 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3744 cifs_dbg(VFS, "persistent handles not supported by server\n");
3745 rc = -EOPNOTSUPP;
3746 goto mount_fail_check;
3747 }
592fafe6 3748
d00c28de 3749 /* search for existing tcon to this server share */
af4281dc 3750 tcon = cifs_get_tcon(ses, volume_info);
d00c28de
JL		 3751 if (IS_ERR(tcon)) {
3752 rc = PTR_ERR(tcon);
3753 tcon = NULL;
40920c2b
MS		 3754 if (rc == -EACCES)
3755 goto mount_fail_check;
3756
1bfe73c2 3757 goto remote_path_check;
d00c28de 3758 }
1bfe73c2 3759
d82c2df5 3760 /* tell server which Unix caps we support */
29e20f9c 3761 if (cap_unix(tcon->ses)) {
d82c2df5
SF		 3762 /* reset of caps checks mount to see if unix extensions
3763 disabled for just this mount */
2c6292ae 3764 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
6848b733
SF		 3765 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3766 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3767 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3768 rc = -EACCES;
3769 goto mount_fail_check;
3770 }
3771 } else
d82c2df5 3772 tcon->unix_ext = 0; /* server does not support them */
c18c842b 3773
af4281dc
PS		 3774 /* do not care if a following call succeed - informational */
3775 if (!tcon->ipc && server->ops->qfs_tcon)
3776 server->ops->qfs_tcon(xid, tcon);
6848b733 3777
24985c53
PS		 3778 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3779 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
f7910cbd 3780
1bfe73c2 3781remote_path_check:
c1508ca2
SF		 3782#ifdef CONFIG_CIFS_DFS_UPCALL
3783 /*
3784 * Perform an unconditional check for whether there are DFS
3785 * referrals for this path without prefix, to provide support
3786 * for DFS referrals from w2k8 servers which don't seem to respond
3787 * with PATH_NOT_COVERED to requests that include the prefix.
3788 * Chase the referral if found, otherwise continue normally.
3789 */
3790 if (referral_walks_count == 0) {
af4281dc
PS		 3791 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3792 false);
c1508ca2
SF		 3793 if (!refrc) {
3794 referral_walks_count++;
3795 goto try_mount_again;
3796 }
3797 }
3798#endif
3799
f87d39d9 3800 /* check if a whole path is not remote */
70945643 3801 if (!rc && tcon) {
68889f26
PS		 3802 if (!server->ops->is_path_accessible) {
3803 rc = -ENOSYS;
3804 goto mount_fail_check;
3805 }
6d3ea7e4
SF		 3806 /*
3807 * cifs_build_path_to_root works only when we have a valid tcon
3808 */
374402a2
SP		 3809 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
3810 tcon->Flags & SMB_SHARE_IS_IN_DFS);
e4cce94c
IM		 3811 if (full_path == NULL) {
3812 rc = -ENOMEM;
3813 goto mount_fail_check;
3814 }
68889f26
PS		 3815 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3816 full_path);
03ceace5 3817 if (rc != 0 && rc != -EREMOTE) {
e4cce94c
IM		 3818 kfree(full_path);
3819 goto mount_fail_check;
3820 }
a6b5058f 3821
d171356f
SP		 3822 if (rc != -EREMOTE) {
3823 rc = cifs_are_all_path_components_accessible(server,
a6b5058f
AA		 3824 xid, tcon, cifs_sb,
3825 full_path);
d171356f
SP		 3826 if (rc != 0) {
3827 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3828 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3829 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3830 rc = 0;
3831 }
a6b5058f 3832 }
e4cce94c
IM		 3833 kfree(full_path);
3834 }
3835
1bfe73c2
IM		 3836 /* get referral if needed */
3837 if (rc == -EREMOTE) {
d036f50f 3838#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8
IM		 3839 if (referral_walks_count > MAX_NESTED_LINKS) {
3840 /*
3841 * BB: when we implement proper loop detection,
3842 * we will remove this check. But now we need it
3843 * to prevent an indefinite loop if 'DFS tree' is
3844 * misconfigured (i.e. has loops).
3845 */
3846 rc = -ELOOP;
3847 goto mount_fail_check;
3848 }
1bfe73c2 3849
af4281dc 3850 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
7b91e266 3851
dd613945 3852 if (!rc) {
5c2503a8 3853 referral_walks_count++;
1bfe73c2
IM		 3854 goto try_mount_again;
3855 }
dd613945 3856 goto mount_fail_check;
d036f50f
SF		 3857#else /* No DFS support, return error on mount */
3858 rc = -EOPNOTSUPP;
3859#endif
1bfe73c2
IM		 3860 }
3861
9d002df4
JL		 3862 if (rc)
3863 goto mount_fail_check;
3864
3865 /* now, hang the tcon off of the superblock */
3866 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3867 if (tlink == NULL) {
3868 rc = -ENOMEM;
3869 goto mount_fail_check;
3870 }
3871
af4281dc 3872 tlink->tl_uid = ses->linux_uid;
9d002df4
JL		 3873 tlink->tl_tcon = tcon;
3874 tlink->tl_time = jiffies;
3875 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3876 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3877
b647c35f 3878 cifs_sb->master_tlink = tlink;
9d002df4 3879 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3880 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
9d002df4 3881 spin_unlock(&cifs_sb->tlink_tree_lock);
413e661c 3882
da472fc8 3883 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 3884 TLINK_IDLE_EXPIRE);
3885
1bfe73c2
IM		 3886mount_fail_check:
3887 /* on error free sesinfo and tcon struct if needed */
3888 if (rc) {
1bfe73c2 3889 /* If find_unc succeeded then rc == 0 so we can not end */
25985edc 3890 /* up accidentally freeing someone elses tcon struct */
1bfe73c2
IM		 3891 if (tcon)
3892 cifs_put_tcon(tcon);
af4281dc
PS		 3893 else if (ses)
3894 cifs_put_smb_ses(ses);
1bfe73c2 3895 else
53e0e11e 3896 cifs_put_tcp_session(server, 0);
1bfe73c2
IM		 3897 }
3898
70fe7dc0 3899out:
6d5786a3 3900 free_xid(xid);
1da177e4
LT		 3901 return rc;
3902}
3903
8d1bca32
JL		 3904/*
3905 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3906 * pointer may be NULL.
3907 */
1da177e4 3908int
2e6e02ab 3909CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
96daf2b0 3910 const char *tree, struct cifs_tcon *tcon,
1da177e4
LT		 3911 const struct nls_table *nls_codepage)
3912{
3913 struct smb_hdr *smb_buffer;
3914 struct smb_hdr *smb_buffer_response;
3915 TCONX_REQ *pSMB;
3916 TCONX_RSP *pSMBr;
3917 unsigned char *bcc_ptr;
3918 int rc = 0;
690c522f
JL		 3919 int length;
3920 __u16 bytes_left, count;
1da177e4
LT		 3921
3922 if (ses == NULL)
3923 return -EIO;
3924
3925 smb_buffer = cifs_buf_get();
ca43e3be 3926 if (smb_buffer == NULL)
1da177e4 3927 return -ENOMEM;
ca43e3be 3928
1da177e4
LT		 3929 smb_buffer_response = smb_buffer;
3930
3931 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3932 NULL /*no tid */ , 4 /*wct */ );
1982c344 3933
88257360 3934 smb_buffer->Mid = get_next_mid(ses->server);
1da177e4
LT		 3935 smb_buffer->Uid = ses->Suid;
3936 pSMB = (TCONX_REQ *) smb_buffer;
3937 pSMBr = (TCONX_RSP *) smb_buffer_response;
3938
3939 pSMB->AndXCommand = 0xFF;
3940 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
1da177e4 3941 bcc_ptr = &pSMB->Password[0];
8d1bca32 3942 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
eeac8047 3943 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
7c7b25bc 3944 *bcc_ptr = 0; /* password is null byte */
eeac8047 3945 bcc_ptr++; /* skip password */
7c7b25bc 3946 /* already aligned so no need to do it below */
eeac8047 3947 } else {
540b2e37 3948 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
eeac8047
SF		 3949 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3950 specified as required (when that support is added to
3951 the vfs in the future) as only NTLM or the much
7c7b25bc 3952 weaker LANMAN (which we do not send by default) is accepted
eeac8047
SF		 3953 by Samba (not sure whether other servers allow
3954 NTLMv2 password here) */
7c7b25bc 3955#ifdef CONFIG_CIFS_WEAK_PW_HASH
04912d6a 3956 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3f618223 3957 (ses->sectype == LANMAN))
d3ba50b1 3958 calc_lanman_hash(tcon->password, ses->server->cryptkey,
96daf2b0 3959 ses->server->sec_mode &
4e53a3fb
JL		 3960 SECMODE_PW_ENCRYPT ? true : false,
3961 bcc_ptr);
7c7b25bc
SF		 3962 else
3963#endif /* CIFS_WEAK_PW_HASH */
ee2c9258 3964 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
9ef5992e 3965 bcc_ptr, nls_codepage);
f3a31a2b
SF		 3966 if (rc) {
3967 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3968 __func__, rc);
3969 cifs_buf_release(smb_buffer);
3970 return rc;
3971 }
eeac8047 3972
540b2e37 3973 bcc_ptr += CIFS_AUTH_RESP_SIZE;
fb8c4b14 3974 if (ses->capabilities & CAP_UNICODE) {
7c7b25bc
SF		 3975 /* must align unicode strings */
3976 *bcc_ptr = 0; /* null byte password */
3977 bcc_ptr++;
3978 }
eeac8047 3979 }
1da177e4 3980
38d77c50 3981 if (ses->server->sign)
1da177e4
LT		 3982 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3983
3984 if (ses->capabilities & CAP_STATUS32) {
3985 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3986 }
3987 if (ses->capabilities & CAP_DFS) {
3988 smb_buffer->Flags2 |= SMBFLG2_DFS;
3989 }
3990 if (ses->capabilities & CAP_UNICODE) {
3991 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3992 length =
acbbb76a 3993 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
50c2f753 3994 6 /* max utf8 char length in bytes */ *
a878fb22
SF		 3995 (/* server len*/ + 256 /* share len */), nls_codepage);
3996 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
1da177e4
LT		 3997 bcc_ptr += 2; /* skip trailing null */
3998 } else { /* ASCII */
1da177e4
LT		 3999 strcpy(bcc_ptr, tree);
4000 bcc_ptr += strlen(tree) + 1;
4001 }
4002 strcpy(bcc_ptr, "?????");
4003 bcc_ptr += strlen("?????");
4004 bcc_ptr += 1;
4005 count = bcc_ptr - &pSMB->Password[0];
be8e3b00
SF		 4006 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4007 pSMB->hdr.smb_buf_length) + count);
1da177e4
LT		 4008 pSMB->ByteCount = cpu_to_le16(count);
4009
133672ef 4010 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
7749981e 4011 0);
1da177e4 4012
1da177e4
LT		 4013 /* above now done in SendReceive */
4014 if ((rc == 0) && (tcon != NULL)) {
0e0d2cf3
SF		 4015 bool is_unicode;
4016
1da177e4 4017 tcon->tidStatus = CifsGood;
3b795210 4018 tcon->need_reconnect = false;
1da177e4
LT		 4019 tcon->tid = smb_buffer_response->Tid;
4020 bcc_ptr = pByteArea(smb_buffer_response);
690c522f 4021 bytes_left = get_bcc(smb_buffer_response);
cc20c031 4022 length = strnlen(bcc_ptr, bytes_left - 2);
0e0d2cf3
SF		 4023 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4024 is_unicode = true;
4025 else
4026 is_unicode = false;
4027
cc20c031 4028
50c2f753 4029 /* skip service field (NB: this field is always ASCII) */
7f8ed420
SF		 4030 if (length == 3) {
4031 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4032 (bcc_ptr[2] == 'C')) {
f96637be 4033 cifs_dbg(FYI, "IPC connection\n");
7f8ed420
SF		 4034 tcon->ipc = 1;
4035 }
4036 } else if (length == 2) {
4037 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4038 /* the most common case */
f96637be 4039 cifs_dbg(FYI, "disk share connection\n");
7f8ed420
SF		 4040 }
4041 }
50c2f753 4042 bcc_ptr += length + 1;
cc20c031 4043 bytes_left -= (length + 1);
46b51d08 4044 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
cc20c031
JL		 4045
4046 /* mostly informational -- no need to fail on error here */
90a98b2f 4047 kfree(tcon->nativeFileSystem);
acbbb76a 4048 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
0e0d2cf3 4049 bytes_left, is_unicode,
cc20c031
JL		 4050 nls_codepage);
4051
f96637be 4052 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
cc20c031 4053
fb8c4b14 4054 if ((smb_buffer_response->WordCount == 3) ||
1a4e15a0
SF		 4055 (smb_buffer_response->WordCount == 7))
4056 /* field is in same location */
3979877e
SF		 4057 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4058 else
4059 tcon->Flags = 0;
f96637be 4060 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
1da177e4 4061 } else if ((rc == 0) && tcon == NULL) {
50c2f753 4062 /* all we need to save for IPC$ connection */
1da177e4
LT		 4063 ses->ipc_tid = smb_buffer_response->Tid;
4064 }
4065
a8a11d39 4066 cifs_buf_release(smb_buffer);
1da177e4
LT		 4067 return rc;
4068}
4069
2e32cf5e
AV		 4070static void delayed_free(struct rcu_head *p)
4071{
4072 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4073 unload_nls(sbi->local_nls);
4074 kfree(sbi);
4075}
4076
2a9b9951
AV		 4077void
4078cifs_umount(struct cifs_sb_info *cifs_sb)
1da177e4 4079{
b647c35f
JL		 4080 struct rb_root *root = &cifs_sb->tlink_tree;
4081 struct rb_node *node;
4082 struct tcon_link *tlink;
9d002df4 4083
2de970ff
JL		 4084 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4085
b647c35f
JL		 4086 spin_lock(&cifs_sb->tlink_tree_lock);
4087 while ((node = rb_first(root))) {
4088 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4089 cifs_get_tlink(tlink);
4090 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4091 rb_erase(node, root);
1da177e4 4092
b647c35f
JL		 4093 spin_unlock(&cifs_sb->tlink_tree_lock);
4094 cifs_put_tlink(tlink);
4095 spin_lock(&cifs_sb->tlink_tree_lock);
4096 }
4097 spin_unlock(&cifs_sb->tlink_tree_lock);
50c2f753 4098
d757d71b 4099 kfree(cifs_sb->mountdata);
a6b5058f 4100 kfree(cifs_sb->prepath);
2e32cf5e 4101 call_rcu(&cifs_sb->rcu, delayed_free);
50c2f753 4102}
1da177e4 4103
286170aa
PS		 4104int
4105cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
1da177e4
LT		 4106{
4107 int rc = 0;
198b5682 4108 struct TCP_Server_Info *server = ses->server;
1da177e4 4109
286170aa
PS		 4110 if (!server->ops->need_neg || !server->ops->negotiate)
4111 return -ENOSYS;
4112
198b5682 4113 /* only send once per connect */
286170aa 4114 if (!server->ops->need_neg(server))
198b5682
JL		 4115 return 0;
4116
45275789 4117 set_credits(server, 1);
286170aa
PS		 4118
4119 rc = server->ops->negotiate(xid, ses);
198b5682
JL		 4120 if (rc == 0) {
4121 spin_lock(&GlobalMid_Lock);
7fdbaa1b 4122 if (server->tcpStatus == CifsNeedNegotiate)
198b5682
JL		 4123 server->tcpStatus = CifsGood;
4124 else
4125 rc = -EHOSTDOWN;
4126 spin_unlock(&GlobalMid_Lock);
198b5682
JL		 4127 }
4128
4129 return rc;
4130}
4131
58c45c58
PS		 4132int
4133cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4134 struct nls_table *nls_info)
198b5682 4135{
58c45c58 4136 int rc = -ENOSYS;
198b5682 4137 struct TCP_Server_Info *server = ses->server;
26b994fa 4138
198b5682 4139 ses->capabilities = server->capabilities;
26b994fa 4140 if (linuxExtEnabled == 0)
29e20f9c 4141 ses->capabilities &= (~server->vals->cap_unix);
20418acd 4142
f96637be 4143 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
96daf2b0 4144 server->sec_mode, server->capabilities, server->timeAdj);
cb7691b6 4145
39f7248d
SW		 4146 if (ses->auth_key.response) {
4147 cifs_dbg(VFS, "Free previous auth_key.response = %p\n",
4148 ses->auth_key.response);
4149 kfree(ses->auth_key.response);
4150 ses->auth_key.response = NULL;
4151 ses->auth_key.len = 0;
4152 }
4153
58c45c58
PS		 4154 if (server->ops->sess_setup)
4155 rc = server->ops->sess_setup(xid, ses, nls_info);
4156
d4e63bd6 4157 if (rc)
f96637be 4158 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
21e73393 4159
1da177e4
LT		 4160 return rc;
4161}
4162
8a8798a5
JL		 4163static int
4164cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4165{
3f618223
JL		 4166 vol->sectype = ses->sectype;
4167
4168 /* krb5 is special, since we don't need username or pw */
4169 if (vol->sectype == Kerberos)
8a8798a5 4170 return 0;
8a8798a5
JL		 4171
4172 return cifs_set_cifscreds(vol, ses);
4173}
4174
96daf2b0 4175static struct cifs_tcon *
6d4a0832 4176cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
9d002df4 4177{
8a8798a5 4178 int rc;
96daf2b0
SF		 4179 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4180 struct cifs_ses *ses;
4181 struct cifs_tcon *tcon = NULL;
9d002df4 4182 struct smb_vol *vol_info;
9d002df4
JL		 4183
4184 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
803ab977
DC		 4185 if (vol_info == NULL)
4186 return ERR_PTR(-ENOMEM);
9d002df4 4187
9d002df4
JL		 4188 vol_info->local_nls = cifs_sb->local_nls;
4189 vol_info->linux_uid = fsuid;
4190 vol_info->cred_uid = fsuid;
4191 vol_info->UNC = master_tcon->treeName;
4192 vol_info->retry = master_tcon->retry;
4193 vol_info->nocase = master_tcon->nocase;
4194 vol_info->local_lease = master_tcon->local_lease;
4195 vol_info->no_linux_ext = !master_tcon->unix_ext;
28e11bd8
JL		 4196 vol_info->sectype = master_tcon->ses->sectype;
4197 vol_info->sign = master_tcon->ses->sign;
9d002df4 4198
8a8798a5
JL		 4199 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4200 if (rc) {
4201 tcon = ERR_PTR(rc);
4202 goto out;
4203 }
9d002df4
JL		 4204
4205 /* get a reference for the same TCP session */
3f9bcca7 4206 spin_lock(&cifs_tcp_ses_lock);
9d002df4 4207 ++master_tcon->ses->server->srv_count;
3f9bcca7 4208 spin_unlock(&cifs_tcp_ses_lock);
9d002df4
JL		 4209
4210 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4211 if (IS_ERR(ses)) {
96daf2b0 4212 tcon = (struct cifs_tcon *)ses;
53e0e11e 4213 cifs_put_tcp_session(master_tcon->ses->server, 0);
9d002df4
JL		 4214 goto out;
4215 }
4216
4217 tcon = cifs_get_tcon(ses, vol_info);
4218 if (IS_ERR(tcon)) {
4219 cifs_put_smb_ses(ses);
4220 goto out;
4221 }
4222
29e20f9c 4223 if (cap_unix(ses))
9d002df4
JL		 4224 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4225out:
8a8798a5
JL		 4226 kfree(vol_info->username);
4227 kfree(vol_info->password);
9d002df4
JL		 4228 kfree(vol_info);
4229
4230 return tcon;
4231}
4232
96daf2b0 4233struct cifs_tcon *
9d002df4
JL		 4234cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4235{
4236 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4237}
4238
b647c35f
JL		 4239/* find and return a tlink with given uid */
4240static struct tcon_link *
6d4a0832 4241tlink_rb_search(struct rb_root *root, kuid_t uid)
b647c35f
JL		 4242{
4243 struct rb_node *node = root->rb_node;
4244 struct tcon_link *tlink;
4245
4246 while (node) {
4247 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4248
6d4a0832 4249 if (uid_gt(tlink->tl_uid, uid))
b647c35f 4250 node = node->rb_left;
6d4a0832 4251 else if (uid_lt(tlink->tl_uid, uid))
b647c35f
JL		 4252 node = node->rb_right;
4253 else
4254 return tlink;
4255 }
4256 return NULL;
4257}
4258
4259/* insert a tcon_link into the tree */
4260static void
4261tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4262{
4263 struct rb_node **new = &(root->rb_node), *parent = NULL;
4264 struct tcon_link *tlink;
4265
4266 while (*new) {
4267 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4268 parent = *new;
4269
6d4a0832 4270 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
b647c35f
JL		 4271 new = &((*new)->rb_left);
4272 else
4273 new = &((*new)->rb_right);
4274 }
4275
4276 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4277 rb_insert_color(&new_tlink->tl_rbnode, root);
4278}
4279
9d002df4
JL		 4280/*
4281 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4282 * current task.
4283 *
4284 * If the superblock doesn't refer to a multiuser mount, then just return
4285 * the master tcon for the mount.
4286 *
6ef933a3 4287 * First, search the rbtree for an existing tcon for this fsuid. If one
9d002df4
JL		 4288 * exists, then check to see if it's pending construction. If it is then wait
4289 * for construction to complete. Once it's no longer pending, check to see if
4290 * it failed and either return an error or retry construction, depending on
4291 * the timeout.
4292 *
4293 * If one doesn't exist then insert a new tcon_link struct into the tree and
4294 * try to construct a new one.
4295 */
4296struct tcon_link *
4297cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4298{
4299 int ret;
6d4a0832 4300 kuid_t fsuid = current_fsuid();
9d002df4
JL		 4301 struct tcon_link *tlink, *newtlink;
4302
4303 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4304 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4305
4306 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 4307 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4308 if (tlink)
4309 cifs_get_tlink(tlink);
4310 spin_unlock(&cifs_sb->tlink_tree_lock);
4311
4312 if (tlink == NULL) {
4313 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4314 if (newtlink == NULL)
4315 return ERR_PTR(-ENOMEM);
b647c35f 4316 newtlink->tl_uid = fsuid;
9d002df4
JL		 4317 newtlink->tl_tcon = ERR_PTR(-EACCES);
4318 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4319 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4320 cifs_get_tlink(newtlink);
4321
9d002df4
JL		 4322 spin_lock(&cifs_sb->tlink_tree_lock);
4323 /* was one inserted after previous search? */
b647c35f 4324 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4325 if (tlink) {
4326 cifs_get_tlink(tlink);
4327 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4328 kfree(newtlink);
4329 goto wait_for_construction;
4330 }
9d002df4 4331 tlink = newtlink;
b647c35f
JL		 4332 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4333 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4334 } else {
4335wait_for_construction:
4336 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
9d002df4
JL		 4337 TASK_INTERRUPTIBLE);
4338 if (ret) {
4339 cifs_put_tlink(tlink);
74316201 4340 return ERR_PTR(-ERESTARTSYS);
9d002df4
JL		 4341 }
4342
4343 /* if it's good, return it */
4344 if (!IS_ERR(tlink->tl_tcon))
4345 return tlink;
4346
4347 /* return error if we tried this already recently */
4348 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4349 cifs_put_tlink(tlink);
4350 return ERR_PTR(-EACCES);
4351 }
4352
4353 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4354 goto wait_for_construction;
4355 }
4356
4357 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4358 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4359 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4360
4361 if (IS_ERR(tlink->tl_tcon)) {
4362 cifs_put_tlink(tlink);
4363 return ERR_PTR(-EACCES);
4364 }
4365
4366 return tlink;
4367}
2de970ff
JL		 4368
4369/*
4370 * periodic workqueue job that scans tcon_tree for a superblock and closes
4371 * out tcons.
4372 */
4373static void
4374cifs_prune_tlinks(struct work_struct *work)
4375{
4376 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4377 prune_tlinks.work);
b647c35f
JL		 4378 struct rb_root *root = &cifs_sb->tlink_tree;
4379 struct rb_node *node = rb_first(root);
4380 struct rb_node *tmp;
4381 struct tcon_link *tlink;
2de970ff 4382
b647c35f
JL		 4383 /*
4384 * Because we drop the spinlock in the loop in order to put the tlink
4385 * it's not guarded against removal of links from the tree. The only
4386 * places that remove entries from the tree are this function and
4387 * umounts. Because this function is non-reentrant and is canceled
4388 * before umount can proceed, this is safe.
4389 */
4390 spin_lock(&cifs_sb->tlink_tree_lock);
4391 node = rb_first(root);
4392 while (node != NULL) {
4393 tmp = node;
4394 node = rb_next(tmp);
4395 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4396
4397 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4398 atomic_read(&tlink->tl_count) != 0 ||
4399 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4400 continue;
2de970ff 4401
b647c35f
JL		 4402 cifs_get_tlink(tlink);
4403 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4404 rb_erase(tmp, root);
4405
4406 spin_unlock(&cifs_sb->tlink_tree_lock);
4407 cifs_put_tlink(tlink);
4408 spin_lock(&cifs_sb->tlink_tree_lock);
4409 }
4410 spin_unlock(&cifs_sb->tlink_tree_lock);
2de970ff 4411
da472fc8 4412 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 4413 TLINK_IDLE_EXPIRE);
4414}
Ubuntu Artful kernel mirror