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