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