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