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