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