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