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