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