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