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