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