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