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