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