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