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