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