projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
CIFS: Allow SMB2 statistics to be tracked
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / cifs / connect.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/connect.c
3 *
1080ef75 4 * Copyright (C) International Business Machines Corp., 2002,2011
1da177e4
LT		 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
fb8c4b14 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1da177e4
LT		 20 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
b8643e1b 31#include <linux/delay.h>
f191401f 32#include <linux/completion.h>
aaf737ad 33#include <linux/kthread.h>
0ae0efad 34#include <linux/pagevec.h>
7dfb7103 35#include <linux/freezer.h>
5c2503a8 36#include <linux/namei.h>
1da177e4
LT		 37#include <asm/uaccess.h>
38#include <asm/processor.h>
50b64e3b 39#include <linux/inet.h>
143cb494 40#include <linux/module.h>
8a8798a5 41#include <keys/user-type.h>
0e2bedaa 42#include <net/ipv6.h>
8830d7e0
SP		 43#include <linux/parser.h>
44
1da177e4
LT		 45#include "cifspdu.h"
46#include "cifsglob.h"
47#include "cifsproto.h"
48#include "cifs_unicode.h"
49#include "cifs_debug.h"
50#include "cifs_fs_sb.h"
51#include "ntlmssp.h"
52#include "nterr.h"
53#include "rfc1002pdu.h"
488f1d2d 54#include "fscache.h"
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
f7910cbd 3264/*
5eba8ab3
JL		 3265 * When the server supports very large reads and writes via POSIX extensions,
3266 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3267 * including the RFC1001 length.
f7910cbd
JL		 3268 *
3269 * Note that this might make for "interesting" allocation problems during
1190f6a0
JL		 3270 * writeback however as we have to allocate an array of pointers for the
3271 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
5eba8ab3
JL		 3272 *
3273 * For reads, there is a similar problem as we need to allocate an array
3274 * of kvecs to handle the receive, though that should only need to be done
3275 * once.
f7910cbd 3276 */
1190f6a0 3277#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
5eba8ab3 3278#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
f7910cbd
JL		 3279
3280/*
5eba8ab3
JL		 3281 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3282 * of 2^17-1 minus the size of the call header. That allows for a read or
3283 * write up to the maximum size described by RFC1002.
f7910cbd 3284 */
94443f43 3285#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
5eba8ab3 3286#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
f7910cbd
JL		 3287
3288/*
3289 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3290 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3291 * a single wsize request with a single call.
3292 */
5eba8ab3
JL		 3293#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3294
3295/*
ce91acb3
JL		 3296 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3297 * those values when posix extensions aren't in force. In actuality here, we
3298 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3299 * to be ok with the extra byte even though Windows doesn't send writes that
3300 * are that large.
3301 *
3302 * Citation:
3303 *
3304 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
5eba8ab3
JL		 3305 */
3306#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
ce91acb3 3307#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
f7910cbd 3308
3ae629d9
JL		 3309/*
3310 * On hosts with high memory, we can't currently support wsize/rsize that are
3311 * larger than we can kmap at once. Cap the rsize/wsize at
3312 * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3313 * larger than that anyway.
3314 */
3315#ifdef CONFIG_HIGHMEM
3316#define CIFS_KMAP_SIZE_LIMIT (LAST_PKMAP * PAGE_CACHE_SIZE)
3317#else /* CONFIG_HIGHMEM */
3318#define CIFS_KMAP_SIZE_LIMIT (1<<24)
3319#endif /* CONFIG_HIGHMEM */
3320
f7910cbd 3321static unsigned int
96daf2b0 3322cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
f7910cbd
JL		 3323{
3324 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3325 struct TCP_Server_Info *server = tcon->ses->server;
ce91acb3
JL		 3326 unsigned int wsize;
3327
3328 /* start with specified wsize, or default */
3329 if (pvolume_info->wsize)
3330 wsize = pvolume_info->wsize;
3331 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3332 wsize = CIFS_DEFAULT_IOSIZE;
3333 else
3334 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
f7910cbd
JL		 3335
3336 /* can server support 24-bit write sizes? (via UNIX extensions) */
3337 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
1190f6a0 3338 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
f7910cbd 3339
1190f6a0
JL		 3340 /*
3341 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3342 * Limit it to max buffer offered by the server, minus the size of the
3343 * WRITEX header, not including the 4 byte RFC1001 length.
3344 */
3345 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3346 (!(server->capabilities & CAP_UNIX) &&
3347 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3348 wsize = min_t(unsigned int, wsize,
3349 server->maxBuf - sizeof(WRITE_REQ) + 4);
f7910cbd 3350
3ae629d9
JL		 3351 /* limit to the amount that we can kmap at once */
3352 wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
3353
f7910cbd
JL		 3354 /* hard limit of CIFS_MAX_WSIZE */
3355 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3356
3357 return wsize;
3358}
3359
5eba8ab3
JL		 3360static unsigned int
3361cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3362{
3363 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3364 struct TCP_Server_Info *server = tcon->ses->server;
3365 unsigned int rsize, defsize;
3366
3367 /*
3368 * Set default value...
3369 *
3370 * HACK alert! Ancient servers have very small buffers. Even though
3371 * MS-CIFS indicates that servers are only limited by the client's
3372 * bufsize for reads, testing against win98se shows that it throws
3373 * INVALID_PARAMETER errors if you try to request too large a read.
ec01d738 3374 * OS/2 just sends back short reads.
5eba8ab3 3375 *
ec01d738
JL		 3376 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3377 * it can't handle a read request larger than its MaxBufferSize either.
5eba8ab3
JL		 3378 */
3379 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3380 defsize = CIFS_DEFAULT_IOSIZE;
3381 else if (server->capabilities & CAP_LARGE_READ_X)
3382 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
5eba8ab3
JL		 3383 else
3384 defsize = server->maxBuf - sizeof(READ_RSP);
3385
3386 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3387
3388 /*
3389 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3390 * the client's MaxBufferSize.
3391 */
3392 if (!(server->capabilities & CAP_LARGE_READ_X))
3393 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3394
3ae629d9
JL		 3395 /* limit to the amount that we can kmap at once */
3396 rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3397
5eba8ab3
JL		 3398 /* hard limit of CIFS_MAX_RSIZE */
3399 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3400
3401 return rsize;
3402}
3403
b9bce2e9
JL		 3404static void
3405cleanup_volume_info_contents(struct smb_vol *volume_info)
1bfe73c2 3406{
b946845a 3407 kfree(volume_info->username);
1bfe73c2 3408 kzfree(volume_info->password);
13589c43
SF		 3409 if (volume_info->UNCip != volume_info->UNC + 2)
3410 kfree(volume_info->UNCip);
95c75454 3411 kfree(volume_info->UNC);
b946845a
SF		 3412 kfree(volume_info->domainname);
3413 kfree(volume_info->iocharset);
1bfe73c2 3414 kfree(volume_info->prepath);
b9bce2e9
JL		 3415}
3416
3417void
3418cifs_cleanup_volume_info(struct smb_vol *volume_info)
3419{
3420 if (!volume_info)
3421 return;
3422 cleanup_volume_info_contents(volume_info);
1bfe73c2 3423 kfree(volume_info);
1bfe73c2
IM		 3424}
3425
b9bce2e9 3426
2d6d589d 3427#ifdef CONFIG_CIFS_DFS_UPCALL
1bfe73c2
IM		 3428/* build_path_to_root returns full path to root when
3429 * we do not have an exiting connection (tcon) */
3430static char *
b2a0fa15 3431build_unc_path_to_root(const struct smb_vol *vol,
1bfe73c2
IM		 3432 const struct cifs_sb_info *cifs_sb)
3433{
b2a0fa15
JL		 3434 char *full_path, *pos;
3435 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3436 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
1bfe73c2 3437
b2a0fa15 3438 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
1bfe73c2
IM		 3439 if (full_path == NULL)
3440 return ERR_PTR(-ENOMEM);
3441
b2a0fa15
JL		 3442 strncpy(full_path, vol->UNC, unc_len);
3443 pos = full_path + unc_len;
3444
3445 if (pplen) {
3446 strncpy(pos, vol->prepath, pplen);
3447 pos += pplen;
3448 }
3449
3450 *pos = '\0'; /* add trailing null */
f87d39d9 3451 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
b2a0fa15 3452 cFYI(1, "%s: full_path=%s", __func__, full_path);
1bfe73c2
IM		 3453 return full_path;
3454}
dd613945
SF		 3455
3456/*
3457 * Perform a dfs referral query for a share and (optionally) prefix
3458 *
046462ab
SF		 3459 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3460 * to a string containing updated options for the submount. Otherwise it
3461 * will be left untouched.
dd613945
SF		 3462 *
3463 * Returns the rc from get_dfs_path to the caller, which can be used to
3464 * determine whether there were referrals.
3465 */
3466static int
b669f33c 3467expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
dd613945 3468 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
046462ab 3469 int check_prefix)
dd613945
SF		 3470{
3471 int rc;
3472 unsigned int num_referrals = 0;
3473 struct dfs_info3_param *referrals = NULL;
3474 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3475
3476 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3477 if (IS_ERR(full_path))
3478 return PTR_ERR(full_path);
3479
3480 /* For DFS paths, skip the first '\' of the UNC */
3481 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3482
b669f33c 3483 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
dd613945
SF		 3484 &num_referrals, &referrals,
3485 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3486
3487 if (!rc && num_referrals > 0) {
3488 char *fake_devname = NULL;
3489
3490 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3491 full_path + 1, referrals,
3492 &fake_devname);
3493
3494 free_dfs_info_array(referrals, num_referrals);
046462ab 3495
dd613945
SF		 3496 if (IS_ERR(mdata)) {
3497 rc = PTR_ERR(mdata);
3498 mdata = NULL;
b9bce2e9
JL		 3499 } else {
3500 cleanup_volume_info_contents(volume_info);
3501 memset(volume_info, '\0', sizeof(*volume_info));
3502 rc = cifs_setup_volume_info(volume_info, mdata,
3503 fake_devname);
dd613945 3504 }
b9bce2e9
JL		 3505 kfree(fake_devname);
3506 kfree(cifs_sb->mountdata);
046462ab 3507 cifs_sb->mountdata = mdata;
dd613945
SF		 3508 }
3509 kfree(full_path);
3510 return rc;
3511}
2d6d589d 3512#endif
1bfe73c2 3513
04db79b0
JL		 3514static int
3515cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3516 const char *devname)
1da177e4 3517{
724d9f1c 3518 int rc = 0;
1da177e4 3519
04db79b0
JL		 3520 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3521 return -EINVAL;
1da177e4 3522
23db65f5 3523
7586b765 3524 if (volume_info->nullauth) {
04febabc
JL		 3525 cFYI(1, "Anonymous login");
3526 kfree(volume_info->username);
3527 volume_info->username = NULL;
7586b765 3528 } else if (volume_info->username) {
1da177e4 3529 /* BB fixme parse for domain name here */
b6b38f70 3530 cFYI(1, "Username: %s", volume_info->username);
1da177e4 3531 } else {
bf820679 3532 cifserror("No username specified");
50c2f753
SF		 3533 /* In userspace mount helper we can get user name from alternate
3534 locations such as env variables and files on disk */
04db79b0 3535 return -EINVAL;
1da177e4
LT		 3536 }
3537
1da177e4 3538 /* this is needed for ASCII cp to Unicode converts */
7586b765 3539 if (volume_info->iocharset == NULL) {
a5fc4ce0
JL		 3540 /* load_nls_default cannot return null */
3541 volume_info->local_nls = load_nls_default();
1da177e4 3542 } else {
a5fc4ce0
JL		 3543 volume_info->local_nls = load_nls(volume_info->iocharset);
3544 if (volume_info->local_nls == NULL) {
b6b38f70
JP		 3545 cERROR(1, "CIFS mount error: iocharset %s not found",
3546 volume_info->iocharset);
04db79b0 3547 return -ELIBACC;
1da177e4
LT		 3548 }
3549 }
724d9f1c 3550
724d9f1c
PS		 3551 return rc;
3552}
3553
04db79b0
JL		 3554struct smb_vol *
3555cifs_get_volume_info(char *mount_data, const char *devname)
3556{
3557 int rc;
3558 struct smb_vol *volume_info;
3559
3560 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3561 if (!volume_info)
3562 return ERR_PTR(-ENOMEM);
3563
3564 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3565 if (rc) {
3566 cifs_cleanup_volume_info(volume_info);
3567 volume_info = ERR_PTR(rc);
3568 }
3569
3570 return volume_info;
3571}
3572
724d9f1c 3573int
2c6292ae 3574cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
724d9f1c 3575{
1daaae8f 3576 int rc;
6d5786a3 3577 unsigned int xid;
af4281dc 3578 struct cifs_ses *ses;
96daf2b0 3579 struct cifs_tcon *tcon;
af4281dc 3580 struct TCP_Server_Info *server;
724d9f1c
PS		 3581 char *full_path;
3582 struct tcon_link *tlink;
3583#ifdef CONFIG_CIFS_DFS_UPCALL
3584 int referral_walks_count = 0;
20547490 3585#endif
dd854466
AV		 3586
3587 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3588 if (rc)
3589 return rc;
3590
20547490 3591#ifdef CONFIG_CIFS_DFS_UPCALL
724d9f1c
PS		 3592try_mount_again:
3593 /* cleanup activities if we're chasing a referral */
3594 if (referral_walks_count) {
3595 if (tcon)
3596 cifs_put_tcon(tcon);
af4281dc
PS		 3597 else if (ses)
3598 cifs_put_smb_ses(ses);
724d9f1c 3599
6d5786a3 3600 free_xid(xid);
724d9f1c
PS		 3601 }
3602#endif
1daaae8f 3603 rc = 0;
724d9f1c 3604 tcon = NULL;
af4281dc
PS		 3605 ses = NULL;
3606 server = NULL;
724d9f1c
PS		 3607 full_path = NULL;
3608 tlink = NULL;
3609
6d5786a3 3610 xid = get_xid();
1da177e4 3611
63c038c2 3612 /* get a reference to a tcp session */
af4281dc
PS		 3613 server = cifs_get_tcp_session(volume_info);
3614 if (IS_ERR(server)) {
3615 rc = PTR_ERR(server);
dd854466 3616 bdi_destroy(&cifs_sb->bdi);
63c038c2 3617 goto out;
1da177e4
LT		 3618 }
3619
36988c76 3620 /* get a reference to a SMB session */
af4281dc
PS		 3621 ses = cifs_get_smb_ses(server, volume_info);
3622 if (IS_ERR(ses)) {
3623 rc = PTR_ERR(ses);
3624 ses = NULL;
36988c76 3625 goto mount_fail_check;
1da177e4 3626 }
50c2f753 3627
d00c28de 3628 /* search for existing tcon to this server share */
af4281dc 3629 tcon = cifs_get_tcon(ses, volume_info);
d00c28de
JL		 3630 if (IS_ERR(tcon)) {
3631 rc = PTR_ERR(tcon);
3632 tcon = NULL;
1bfe73c2 3633 goto remote_path_check;
d00c28de 3634 }
1bfe73c2 3635
d82c2df5 3636 /* tell server which Unix caps we support */
6848b733 3637 if (tcon->ses->capabilities & CAP_UNIX) {
d82c2df5
SF		 3638 /* reset of caps checks mount to see if unix extensions
3639 disabled for just this mount */
2c6292ae 3640 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
6848b733
SF		 3641 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3642 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3643 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3644 rc = -EACCES;
3645 goto mount_fail_check;
3646 }
3647 } else
d82c2df5 3648 tcon->unix_ext = 0; /* server does not support them */
c18c842b 3649
af4281dc
PS		 3650 /* do not care if a following call succeed - informational */
3651 if (!tcon->ipc && server->ops->qfs_tcon)
3652 server->ops->qfs_tcon(xid, tcon);
6848b733 3653
f7910cbd 3654 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
5eba8ab3 3655 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
f7910cbd 3656
66bfaadc 3657 /* tune readahead according to rsize */
8f71465c 3658 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
f7910cbd 3659
1bfe73c2 3660remote_path_check:
c1508ca2
SF		 3661#ifdef CONFIG_CIFS_DFS_UPCALL
3662 /*
3663 * Perform an unconditional check for whether there are DFS
3664 * referrals for this path without prefix, to provide support
3665 * for DFS referrals from w2k8 servers which don't seem to respond
3666 * with PATH_NOT_COVERED to requests that include the prefix.
3667 * Chase the referral if found, otherwise continue normally.
3668 */
3669 if (referral_walks_count == 0) {
af4281dc
PS		 3670 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3671 false);
c1508ca2
SF		 3672 if (!refrc) {
3673 referral_walks_count++;
3674 goto try_mount_again;
3675 }
3676 }
3677#endif
3678
f87d39d9 3679 /* check if a whole path is not remote */
70945643 3680 if (!rc && tcon) {
68889f26
PS		 3681 if (!server->ops->is_path_accessible) {
3682 rc = -ENOSYS;
3683 goto mount_fail_check;
3684 }
e4cce94c 3685 /* build_path_to_root works only when we have a valid tcon */
9224dfc2 3686 full_path = build_path_to_root(volume_info, cifs_sb, tcon);
e4cce94c
IM		 3687 if (full_path == NULL) {
3688 rc = -ENOMEM;
3689 goto mount_fail_check;
3690 }
68889f26
PS		 3691 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3692 full_path);
03ceace5 3693 if (rc != 0 && rc != -EREMOTE) {
e4cce94c
IM		 3694 kfree(full_path);
3695 goto mount_fail_check;
3696 }
3697 kfree(full_path);
3698 }
3699
1bfe73c2
IM		 3700 /* get referral if needed */
3701 if (rc == -EREMOTE) {
d036f50f 3702#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8
IM		 3703 if (referral_walks_count > MAX_NESTED_LINKS) {
3704 /*
3705 * BB: when we implement proper loop detection,
3706 * we will remove this check. But now we need it
3707 * to prevent an indefinite loop if 'DFS tree' is
3708 * misconfigured (i.e. has loops).
3709 */
3710 rc = -ELOOP;
3711 goto mount_fail_check;
3712 }
1bfe73c2 3713
af4281dc 3714 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
7b91e266 3715
dd613945 3716 if (!rc) {
5c2503a8 3717 referral_walks_count++;
1bfe73c2
IM		 3718 goto try_mount_again;
3719 }
dd613945 3720 goto mount_fail_check;
d036f50f
SF		 3721#else /* No DFS support, return error on mount */
3722 rc = -EOPNOTSUPP;
3723#endif
1bfe73c2
IM		 3724 }
3725
9d002df4
JL		 3726 if (rc)
3727 goto mount_fail_check;
3728
3729 /* now, hang the tcon off of the superblock */
3730 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3731 if (tlink == NULL) {
3732 rc = -ENOMEM;
3733 goto mount_fail_check;
3734 }
3735
af4281dc 3736 tlink->tl_uid = ses->linux_uid;
9d002df4
JL		 3737 tlink->tl_tcon = tcon;
3738 tlink->tl_time = jiffies;
3739 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3740 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3741
b647c35f 3742 cifs_sb->master_tlink = tlink;
9d002df4 3743 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3744 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
9d002df4 3745 spin_unlock(&cifs_sb->tlink_tree_lock);
413e661c 3746
da472fc8 3747 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 3748 TLINK_IDLE_EXPIRE);
3749
1bfe73c2
IM		 3750mount_fail_check:
3751 /* on error free sesinfo and tcon struct if needed */
3752 if (rc) {
1bfe73c2 3753 /* If find_unc succeeded then rc == 0 so we can not end */
25985edc 3754 /* up accidentally freeing someone elses tcon struct */
1bfe73c2
IM		 3755 if (tcon)
3756 cifs_put_tcon(tcon);
af4281dc
PS		 3757 else if (ses)
3758 cifs_put_smb_ses(ses);
1bfe73c2 3759 else
af4281dc 3760 cifs_put_tcp_session(server);
dd854466 3761 bdi_destroy(&cifs_sb->bdi);
1bfe73c2
IM		 3762 }
3763
70fe7dc0 3764out:
6d5786a3 3765 free_xid(xid);
1da177e4
LT		 3766 return rc;
3767}
3768
8d1bca32
JL		 3769/*
3770 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3771 * pointer may be NULL.
3772 */
1da177e4 3773int
2e6e02ab 3774CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
96daf2b0 3775 const char *tree, struct cifs_tcon *tcon,
1da177e4
LT		 3776 const struct nls_table *nls_codepage)
3777{
3778 struct smb_hdr *smb_buffer;
3779 struct smb_hdr *smb_buffer_response;
3780 TCONX_REQ *pSMB;
3781 TCONX_RSP *pSMBr;
3782 unsigned char *bcc_ptr;
3783 int rc = 0;
690c522f
JL		 3784 int length;
3785 __u16 bytes_left, count;
1da177e4
LT		 3786
3787 if (ses == NULL)
3788 return -EIO;
3789
3790 smb_buffer = cifs_buf_get();
ca43e3be 3791 if (smb_buffer == NULL)
1da177e4 3792 return -ENOMEM;
ca43e3be 3793
1da177e4
LT		 3794 smb_buffer_response = smb_buffer;
3795
3796 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3797 NULL /*no tid */ , 4 /*wct */ );
1982c344 3798
88257360 3799 smb_buffer->Mid = get_next_mid(ses->server);
1da177e4
LT		 3800 smb_buffer->Uid = ses->Suid;
3801 pSMB = (TCONX_REQ *) smb_buffer;
3802 pSMBr = (TCONX_RSP *) smb_buffer_response;
3803
3804 pSMB->AndXCommand = 0xFF;
3805 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
1da177e4 3806 bcc_ptr = &pSMB->Password[0];
8d1bca32 3807 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
eeac8047 3808 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
7c7b25bc 3809 *bcc_ptr = 0; /* password is null byte */
eeac8047 3810 bcc_ptr++; /* skip password */
7c7b25bc 3811 /* already aligned so no need to do it below */
eeac8047 3812 } else {
540b2e37 3813 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
eeac8047
SF		 3814 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3815 specified as required (when that support is added to
3816 the vfs in the future) as only NTLM or the much
7c7b25bc 3817 weaker LANMAN (which we do not send by default) is accepted
eeac8047
SF		 3818 by Samba (not sure whether other servers allow
3819 NTLMv2 password here) */
7c7b25bc 3820#ifdef CONFIG_CIFS_WEAK_PW_HASH
04912d6a 3821 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
00e485b0 3822 (ses->server->secType == LANMAN))
d3ba50b1 3823 calc_lanman_hash(tcon->password, ses->server->cryptkey,
96daf2b0 3824 ses->server->sec_mode &
4e53a3fb
JL		 3825 SECMODE_PW_ENCRYPT ? true : false,
3826 bcc_ptr);
7c7b25bc
SF		 3827 else
3828#endif /* CIFS_WEAK_PW_HASH */
ee2c9258 3829 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
9ef5992e 3830 bcc_ptr, nls_codepage);
eeac8047 3831
540b2e37 3832 bcc_ptr += CIFS_AUTH_RESP_SIZE;
fb8c4b14 3833 if (ses->capabilities & CAP_UNICODE) {
7c7b25bc
SF		 3834 /* must align unicode strings */
3835 *bcc_ptr = 0; /* null byte password */
3836 bcc_ptr++;
3837 }
eeac8047 3838 }
1da177e4 3839
96daf2b0 3840 if (ses->server->sec_mode &
a878fb22 3841 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1da177e4
LT		 3842 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3843
3844 if (ses->capabilities & CAP_STATUS32) {
3845 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3846 }
3847 if (ses->capabilities & CAP_DFS) {
3848 smb_buffer->Flags2 |= SMBFLG2_DFS;
3849 }
3850 if (ses->capabilities & CAP_UNICODE) {
3851 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3852 length =
acbbb76a 3853 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
50c2f753 3854 6 /* max utf8 char length in bytes */ *
a878fb22
SF		 3855 (/* server len*/ + 256 /* share len */), nls_codepage);
3856 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
1da177e4
LT		 3857 bcc_ptr += 2; /* skip trailing null */
3858 } else { /* ASCII */
1da177e4
LT		 3859 strcpy(bcc_ptr, tree);
3860 bcc_ptr += strlen(tree) + 1;
3861 }
3862 strcpy(bcc_ptr, "?????");
3863 bcc_ptr += strlen("?????");
3864 bcc_ptr += 1;
3865 count = bcc_ptr - &pSMB->Password[0];
be8e3b00
SF		 3866 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3867 pSMB->hdr.smb_buf_length) + count);
1da177e4
LT		 3868 pSMB->ByteCount = cpu_to_le16(count);
3869
133672ef 3870 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
7749981e 3871 0);
1da177e4 3872
1da177e4
LT		 3873 /* above now done in SendReceive */
3874 if ((rc == 0) && (tcon != NULL)) {
0e0d2cf3
SF		 3875 bool is_unicode;
3876
1da177e4 3877 tcon->tidStatus = CifsGood;
3b795210 3878 tcon->need_reconnect = false;
1da177e4
LT		 3879 tcon->tid = smb_buffer_response->Tid;
3880 bcc_ptr = pByteArea(smb_buffer_response);
690c522f 3881 bytes_left = get_bcc(smb_buffer_response);
cc20c031 3882 length = strnlen(bcc_ptr, bytes_left - 2);
0e0d2cf3
SF		 3883 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3884 is_unicode = true;
3885 else
3886 is_unicode = false;
3887
cc20c031 3888
50c2f753 3889 /* skip service field (NB: this field is always ASCII) */
7f8ed420
SF		 3890 if (length == 3) {
3891 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3892 (bcc_ptr[2] == 'C')) {
b6b38f70 3893 cFYI(1, "IPC connection");
7f8ed420
SF		 3894 tcon->ipc = 1;
3895 }
3896 } else if (length == 2) {
3897 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3898 /* the most common case */
b6b38f70 3899 cFYI(1, "disk share connection");
7f8ed420
SF		 3900 }
3901 }
50c2f753 3902 bcc_ptr += length + 1;
cc20c031 3903 bytes_left -= (length + 1);
1da177e4 3904 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
cc20c031
JL		 3905
3906 /* mostly informational -- no need to fail on error here */
90a98b2f 3907 kfree(tcon->nativeFileSystem);
acbbb76a 3908 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
0e0d2cf3 3909 bytes_left, is_unicode,
cc20c031
JL		 3910 nls_codepage);
3911
b6b38f70 3912 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
cc20c031 3913
fb8c4b14 3914 if ((smb_buffer_response->WordCount == 3) ||
1a4e15a0
SF		 3915 (smb_buffer_response->WordCount == 7))
3916 /* field is in same location */
3979877e
SF		 3917 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3918 else
3919 tcon->Flags = 0;
b6b38f70 3920 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
1da177e4 3921 } else if ((rc == 0) && tcon == NULL) {
50c2f753 3922 /* all we need to save for IPC$ connection */
1da177e4
LT		 3923 ses->ipc_tid = smb_buffer_response->Tid;
3924 }
3925
a8a11d39 3926 cifs_buf_release(smb_buffer);
1da177e4
LT		 3927 return rc;
3928}
3929
2a9b9951
AV		 3930void
3931cifs_umount(struct cifs_sb_info *cifs_sb)
1da177e4 3932{
b647c35f
JL		 3933 struct rb_root *root = &cifs_sb->tlink_tree;
3934 struct rb_node *node;
3935 struct tcon_link *tlink;
9d002df4 3936
2de970ff
JL		 3937 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3938
b647c35f
JL		 3939 spin_lock(&cifs_sb->tlink_tree_lock);
3940 while ((node = rb_first(root))) {
3941 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3942 cifs_get_tlink(tlink);
3943 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3944 rb_erase(node, root);
1da177e4 3945
b647c35f
JL		 3946 spin_unlock(&cifs_sb->tlink_tree_lock);
3947 cifs_put_tlink(tlink);
3948 spin_lock(&cifs_sb->tlink_tree_lock);
3949 }
3950 spin_unlock(&cifs_sb->tlink_tree_lock);
50c2f753 3951
dd854466 3952 bdi_destroy(&cifs_sb->bdi);
d757d71b
AV		 3953 kfree(cifs_sb->mountdata);
3954 unload_nls(cifs_sb->local_nls);
3955 kfree(cifs_sb);
50c2f753 3956}
1da177e4 3957
286170aa
PS		 3958int
3959cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
1da177e4
LT		 3960{
3961 int rc = 0;
198b5682 3962 struct TCP_Server_Info *server = ses->server;
1da177e4 3963
286170aa
PS		 3964 if (!server->ops->need_neg || !server->ops->negotiate)
3965 return -ENOSYS;
3966
198b5682 3967 /* only send once per connect */
286170aa 3968 if (!server->ops->need_neg(server))
198b5682
JL		 3969 return 0;
3970
45275789 3971 set_credits(server, 1);
286170aa
PS		 3972
3973 rc = server->ops->negotiate(xid, ses);
198b5682
JL		 3974 if (rc == 0) {
3975 spin_lock(&GlobalMid_Lock);
7fdbaa1b 3976 if (server->tcpStatus == CifsNeedNegotiate)
198b5682
JL		 3977 server->tcpStatus = CifsGood;
3978 else
3979 rc = -EHOSTDOWN;
3980 spin_unlock(&GlobalMid_Lock);
198b5682
JL		 3981 }
3982
3983 return rc;
3984}
3985
58c45c58
PS		 3986int
3987cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3988 struct nls_table *nls_info)
198b5682 3989{
58c45c58 3990 int rc = -ENOSYS;
198b5682 3991 struct TCP_Server_Info *server = ses->server;
26b994fa 3992
198b5682
JL		 3993 ses->flags = 0;
3994 ses->capabilities = server->capabilities;
26b994fa 3995 if (linuxExtEnabled == 0)
198b5682 3996 ses->capabilities &= (~CAP_UNIX);
20418acd 3997
b6b38f70 3998 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
96daf2b0 3999 server->sec_mode, server->capabilities, server->timeAdj);
cb7691b6 4000
58c45c58
PS		 4001 if (server->ops->sess_setup)
4002 rc = server->ops->sess_setup(xid, ses, nls_info);
4003
26b994fa 4004 if (rc) {
b6b38f70 4005 cERROR(1, "Send error in SessSetup = %d", rc);
26b994fa 4006 } else {
5d0d2882
SP		 4007 mutex_lock(&ses->server->srv_mutex);
4008 if (!server->session_estab) {
21e73393 4009 server->session_key.response = ses->auth_key.response;
5d0d2882 4010 server->session_key.len = ses->auth_key.len;
21e73393
SP		 4011 server->sequence_number = 0x2;
4012 server->session_estab = true;
4013 ses->auth_key.response = NULL;
5d0d2882
SP		 4014 }
4015 mutex_unlock(&server->srv_mutex);
4016
b6b38f70 4017 cFYI(1, "CIFS Session Established successfully");
20418acd 4018 spin_lock(&GlobalMid_Lock);
198b5682
JL		 4019 ses->status = CifsGood;
4020 ses->need_reconnect = false;
20418acd 4021 spin_unlock(&GlobalMid_Lock);
1da177e4 4022 }
26b994fa 4023
21e73393
SP		 4024 kfree(ses->auth_key.response);
4025 ses->auth_key.response = NULL;
4026 ses->auth_key.len = 0;
d3686d54
SP		 4027 kfree(ses->ntlmssp);
4028 ses->ntlmssp = NULL;
21e73393 4029
1da177e4
LT		 4030 return rc;
4031}
4032
8a8798a5
JL		 4033static int
4034cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4035{
4036 switch (ses->server->secType) {
4037 case Kerberos:
4038 vol->secFlg = CIFSSEC_MUST_KRB5;
4039 return 0;
4040 case NTLMv2:
4041 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4042 break;
4043 case NTLM:
4044 vol->secFlg = CIFSSEC_MUST_NTLM;
4045 break;
4046 case RawNTLMSSP:
4047 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4048 break;
4049 case LANMAN:
4050 vol->secFlg = CIFSSEC_MUST_LANMAN;
4051 break;
4052 }
4053
4054 return cifs_set_cifscreds(vol, ses);
4055}
4056
96daf2b0 4057static struct cifs_tcon *
9d002df4
JL		 4058cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4059{
8a8798a5 4060 int rc;
96daf2b0
SF		 4061 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4062 struct cifs_ses *ses;
4063 struct cifs_tcon *tcon = NULL;
9d002df4 4064 struct smb_vol *vol_info;
9d002df4
JL		 4065
4066 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
803ab977
DC		 4067 if (vol_info == NULL)
4068 return ERR_PTR(-ENOMEM);
9d002df4 4069
9d002df4
JL		 4070 vol_info->local_nls = cifs_sb->local_nls;
4071 vol_info->linux_uid = fsuid;
4072 vol_info->cred_uid = fsuid;
4073 vol_info->UNC = master_tcon->treeName;
4074 vol_info->retry = master_tcon->retry;
4075 vol_info->nocase = master_tcon->nocase;
4076 vol_info->local_lease = master_tcon->local_lease;
4077 vol_info->no_linux_ext = !master_tcon->unix_ext;
4078
8a8798a5
JL		 4079 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4080 if (rc) {
4081 tcon = ERR_PTR(rc);
4082 goto out;
4083 }
9d002df4
JL		 4084
4085 /* get a reference for the same TCP session */
3f9bcca7 4086 spin_lock(&cifs_tcp_ses_lock);
9d002df4 4087 ++master_tcon->ses->server->srv_count;
3f9bcca7 4088 spin_unlock(&cifs_tcp_ses_lock);
9d002df4
JL		 4089
4090 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4091 if (IS_ERR(ses)) {
96daf2b0 4092 tcon = (struct cifs_tcon *)ses;
9d002df4
JL		 4093 cifs_put_tcp_session(master_tcon->ses->server);
4094 goto out;
4095 }
4096
4097 tcon = cifs_get_tcon(ses, vol_info);
4098 if (IS_ERR(tcon)) {
4099 cifs_put_smb_ses(ses);
4100 goto out;
4101 }
4102
4103 if (ses->capabilities & CAP_UNIX)
4104 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4105out:
8a8798a5
JL		 4106 kfree(vol_info->username);
4107 kfree(vol_info->password);
9d002df4
JL		 4108 kfree(vol_info);
4109
4110 return tcon;
4111}
4112
96daf2b0 4113struct cifs_tcon *
9d002df4
JL		 4114cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4115{
4116 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4117}
4118
4119static int
4120cifs_sb_tcon_pending_wait(void *unused)
4121{
4122 schedule();
4123 return signal_pending(current) ? -ERESTARTSYS : 0;
4124}
4125
b647c35f
JL		 4126/* find and return a tlink with given uid */
4127static struct tcon_link *
4128tlink_rb_search(struct rb_root *root, uid_t uid)
4129{
4130 struct rb_node *node = root->rb_node;
4131 struct tcon_link *tlink;
4132
4133 while (node) {
4134 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4135
4136 if (tlink->tl_uid > uid)
4137 node = node->rb_left;
4138 else if (tlink->tl_uid < uid)
4139 node = node->rb_right;
4140 else
4141 return tlink;
4142 }
4143 return NULL;
4144}
4145
4146/* insert a tcon_link into the tree */
4147static void
4148tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4149{
4150 struct rb_node **new = &(root->rb_node), *parent = NULL;
4151 struct tcon_link *tlink;
4152
4153 while (*new) {
4154 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4155 parent = *new;
4156
4157 if (tlink->tl_uid > new_tlink->tl_uid)
4158 new = &((*new)->rb_left);
4159 else
4160 new = &((*new)->rb_right);
4161 }
4162
4163 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4164 rb_insert_color(&new_tlink->tl_rbnode, root);
4165}
4166
9d002df4
JL		 4167/*
4168 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4169 * current task.
4170 *
4171 * If the superblock doesn't refer to a multiuser mount, then just return
4172 * the master tcon for the mount.
4173 *
6ef933a3 4174 * First, search the rbtree for an existing tcon for this fsuid. If one
9d002df4
JL		 4175 * exists, then check to see if it's pending construction. If it is then wait
4176 * for construction to complete. Once it's no longer pending, check to see if
4177 * it failed and either return an error or retry construction, depending on
4178 * the timeout.
4179 *
4180 * If one doesn't exist then insert a new tcon_link struct into the tree and
4181 * try to construct a new one.
4182 */
4183struct tcon_link *
4184cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4185{
4186 int ret;
b647c35f 4187 uid_t fsuid = current_fsuid();
9d002df4
JL		 4188 struct tcon_link *tlink, *newtlink;
4189
4190 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4191 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4192
4193 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 4194 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4195 if (tlink)
4196 cifs_get_tlink(tlink);
4197 spin_unlock(&cifs_sb->tlink_tree_lock);
4198
4199 if (tlink == NULL) {
4200 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4201 if (newtlink == NULL)
4202 return ERR_PTR(-ENOMEM);
b647c35f 4203 newtlink->tl_uid = fsuid;
9d002df4
JL		 4204 newtlink->tl_tcon = ERR_PTR(-EACCES);
4205 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4206 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4207 cifs_get_tlink(newtlink);
4208
9d002df4
JL		 4209 spin_lock(&cifs_sb->tlink_tree_lock);
4210 /* was one inserted after previous search? */
b647c35f 4211 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4212 if (tlink) {
4213 cifs_get_tlink(tlink);
4214 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4215 kfree(newtlink);
4216 goto wait_for_construction;
4217 }
9d002df4 4218 tlink = newtlink;
b647c35f
JL		 4219 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4220 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4221 } else {
4222wait_for_construction:
4223 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4224 cifs_sb_tcon_pending_wait,
4225 TASK_INTERRUPTIBLE);
4226 if (ret) {
4227 cifs_put_tlink(tlink);
4228 return ERR_PTR(ret);
4229 }
4230
4231 /* if it's good, return it */
4232 if (!IS_ERR(tlink->tl_tcon))
4233 return tlink;
4234
4235 /* return error if we tried this already recently */
4236 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4237 cifs_put_tlink(tlink);
4238 return ERR_PTR(-EACCES);
4239 }
4240
4241 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4242 goto wait_for_construction;
4243 }
4244
4245 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4246 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4247 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4248
4249 if (IS_ERR(tlink->tl_tcon)) {
4250 cifs_put_tlink(tlink);
4251 return ERR_PTR(-EACCES);
4252 }
4253
4254 return tlink;
4255}
2de970ff
JL		 4256
4257/*
4258 * periodic workqueue job that scans tcon_tree for a superblock and closes
4259 * out tcons.
4260 */
4261static void
4262cifs_prune_tlinks(struct work_struct *work)
4263{
4264 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4265 prune_tlinks.work);
b647c35f
JL		 4266 struct rb_root *root = &cifs_sb->tlink_tree;
4267 struct rb_node *node = rb_first(root);
4268 struct rb_node *tmp;
4269 struct tcon_link *tlink;
2de970ff 4270
b647c35f
JL		 4271 /*
4272 * Because we drop the spinlock in the loop in order to put the tlink
4273 * it's not guarded against removal of links from the tree. The only
4274 * places that remove entries from the tree are this function and
4275 * umounts. Because this function is non-reentrant and is canceled
4276 * before umount can proceed, this is safe.
4277 */
4278 spin_lock(&cifs_sb->tlink_tree_lock);
4279 node = rb_first(root);
4280 while (node != NULL) {
4281 tmp = node;
4282 node = rb_next(tmp);
4283 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4284
4285 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4286 atomic_read(&tlink->tl_count) != 0 ||
4287 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4288 continue;
2de970ff 4289
b647c35f
JL		 4290 cifs_get_tlink(tlink);
4291 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4292 rb_erase(tmp, root);
4293
4294 spin_unlock(&cifs_sb->tlink_tree_lock);
4295 cifs_put_tlink(tlink);
4296 spin_lock(&cifs_sb->tlink_tree_lock);
4297 }
4298 spin_unlock(&cifs_sb->tlink_tree_lock);
2de970ff 4299
da472fc8 4300 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 4301 TLINK_IDLE_EXPIRE);
4302}
kernel source for telekom puls (alcatel/mediatek)