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