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