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