projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'timer/cleanup' into late/mvebu2
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / cifs / connect.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/connect.c
3 *
1080ef75 4 * Copyright (C) International Business Machines Corp., 2002,2011
1da177e4
LT		 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
fb8c4b14 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1da177e4
LT		 20 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
b8643e1b 31#include <linux/delay.h>
f191401f 32#include <linux/completion.h>
aaf737ad 33#include <linux/kthread.h>
0ae0efad 34#include <linux/pagevec.h>
7dfb7103 35#include <linux/freezer.h>
5c2503a8 36#include <linux/namei.h>
1da177e4
LT		 37#include <asm/uaccess.h>
38#include <asm/processor.h>
50b64e3b 39#include <linux/inet.h>
143cb494 40#include <linux/module.h>
8a8798a5 41#include <keys/user-type.h>
0e2bedaa 42#include <net/ipv6.h>
8830d7e0
SP		 43#include <linux/parser.h>
44
1da177e4
LT		 45#include "cifspdu.h"
46#include "cifsglob.h"
47#include "cifsproto.h"
48#include "cifs_unicode.h"
49#include "cifs_debug.h"
50#include "cifs_fs_sb.h"
51#include "ntlmssp.h"
52#include "nterr.h"
53#include "rfc1002pdu.h"
488f1d2d 54#include "fscache.h"
1da177e4
LT		 55
56#define CIFS_PORT 445
57#define RFC1001_PORT 139
58
1da177e4
LT		 59extern mempool_t *cifs_req_poolp;
60
2de970ff 61/* FIXME: should these be tunable? */
9d002df4 62#define TLINK_ERROR_EXPIRE (1 * HZ)
2de970ff 63#define TLINK_IDLE_EXPIRE (600 * HZ)
9d002df4 64
8830d7e0
SP		 65enum {
66
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
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
990
991static int cifs_parse_security_flavors(char *value,
992 struct smb_vol *vol)
993{
994
995 substring_t args[MAX_OPT_ARGS];
996
997 switch (match_token(value, cifs_secflavor_tokens, args)) {
998 case Opt_sec_krb5:
999 vol->secFlg |= CIFSSEC_MAY_KRB5;
1000 break;
1001 case Opt_sec_krb5i:
1002 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1003 break;
1004 case Opt_sec_krb5p:
1005 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1006 cERROR(1, "Krb5 cifs privacy not supported");
1007 break;
1008 case Opt_sec_ntlmssp:
1009 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1010 break;
1011 case Opt_sec_ntlmsspi:
1012 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1013 break;
1014 case Opt_ntlm:
1015 /* ntlm is default so can be turned off too */
1016 vol->secFlg |= CIFSSEC_MAY_NTLM;
1017 break;
1018 case Opt_sec_ntlmi:
1019 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1020 break;
7659624f 1021 case Opt_sec_ntlmv2:
8830d7e0
SP		 1022 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1023 break;
1024 case Opt_sec_ntlmv2i:
1025 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1026 break;
1027#ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman:
1029 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1030 break;
1031#endif
1032 case Opt_sec_none:
1033 vol->nullauth = 1;
1034 break;
1035 default:
1036 cERROR(1, "bad security option: %s", value);
1037 return 1;
1038 }
1039
1040 return 0;
1041}
1042
15b6a473
JL		 1043static int
1044cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1045{
1046 substring_t args[MAX_OPT_ARGS];
1047
1048 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049 case Opt_cache_loose:
1050 vol->direct_io = false;
1051 vol->strict_io = false;
1052 break;
1053 case Opt_cache_strict:
1054 vol->direct_io = false;
1055 vol->strict_io = true;
1056 break;
1057 case Opt_cache_none:
1058 vol->direct_io = true;
1059 vol->strict_io = false;
1060 break;
1061 default:
1062 cERROR(1, "bad cache= option: %s", value);
1063 return 1;
1064 }
1065 return 0;
1066}
1067
23db65f5
JL		 1068static int
1069cifs_parse_smb_version(char *value, struct smb_vol *vol)
1070{
1071 substring_t args[MAX_OPT_ARGS];
1072
1073 switch (match_token(value, cifs_smb_version_tokens, args)) {
1074 case Smb_1:
1075 vol->ops = &smb1_operations;
1076 vol->vals = &smb1_values;
1077 break;
1080ef75 1078#ifdef CONFIG_CIFS_SMB2
dd446b16
SF		 1079 case Smb_20:
1080 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1081 vol->vals = &smb20_values;
1082 break;
1080ef75
SF		 1083 case Smb_21:
1084 vol->ops = &smb21_operations;
1085 vol->vals = &smb21_values;
1086 break;
e4aa25e7 1087 case Smb_30:
38107d45 1088 vol->ops = &smb30_operations;
e4aa25e7
SF		 1089 vol->vals = &smb30_values;
1090 break;
1080ef75 1091#endif
23db65f5
JL		 1092 default:
1093 cERROR(1, "Unknown vers= option specified: %s", value);
1094 return 1;
1095 }
1096 return 0;
1097}
1098
d387a5c5
JL		 1099/*
1100 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1101 * fields with the result. Returns 0 on success and an error otherwise.
1102 */
1103static int
1104cifs_parse_devname(const char *devname, struct smb_vol *vol)
1105{
1106 char *pos;
1107 const char *delims = "/\\";
1108 size_t len;
1109
1110 /* make sure we have a valid UNC double delimiter prefix */
1111 len = strspn(devname, delims);
1112 if (len != 2)
1113 return -EINVAL;
1114
1115 /* find delimiter between host and sharename */
1116 pos = strpbrk(devname + 2, delims);
1117 if (!pos)
1118 return -EINVAL;
1119
1120 /* skip past delimiter */
1121 ++pos;
1122
1123 /* now go until next delimiter or end of string */
1124 len = strcspn(pos, delims);
1125
1126 /* move "pos" up to delimiter or NULL */
1127 pos += len;
1128 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1129 if (!vol->UNC)
1130 return -ENOMEM;
1131
1132 convert_delimiter(vol->UNC, '\\');
1133
1134 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1135 if (!*pos++ || !*pos)
1136 return 0;
1137
1138 vol->prepath = kstrdup(pos, GFP_KERNEL);
1139 if (!vol->prepath)
1140 return -ENOMEM;
1141
1142 return 0;
1143}
1144
1da177e4 1145static int
b946845a 1146cifs_parse_mount_options(const char *mountdata, const char *devname,
50c2f753 1147 struct smb_vol *vol)
1da177e4 1148{
8830d7e0 1149 char *data, *end;
957df453 1150 char *mountdata_copy = NULL, *options;
1da177e4
LT		 1151 unsigned int temp_len, i, j;
1152 char separator[2];
9b9d6b24
JL		 1153 short int override_uid = -1;
1154 short int override_gid = -1;
1155 bool uid_specified = false;
1156 bool gid_specified = false;
d8162558
JL		 1157 bool sloppy = false;
1158 char *invalid = NULL;
88463999 1159 char *nodename = utsname()->nodename;
8830d7e0
SP		 1160 char *string = NULL;
1161 char *tmp_end, *value;
1162 char delim;
b979aaa1
JL		 1163 bool got_ip = false;
1164 unsigned short port = 0;
1165 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1da177e4
LT		 1166
1167 separator[0] = ',';
50c2f753 1168 separator[1] = 0;
8830d7e0 1169 delim = separator[0];
1da177e4 1170
6ee9542a
JL		 1171 /* ensure we always start with zeroed-out smb_vol */
1172 memset(vol, 0, sizeof(*vol));
1173
88463999
JL		 1174 /*
1175 * does not have to be perfect mapping since field is
1176 * informational, only used for servers that do not support
1177 * port 445 and it can be overridden at mount time
1178 */
1397f2ee
JL		 1179 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1180 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
88463999
JL		 1181 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1182
1397f2ee 1183 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
a10faeb2
SF		 1184 /* null target name indicates to use *SMBSERVR default called name
1185 if we end up sending RFC1001 session initialize */
1186 vol->target_rfc1001_name[0] = 0;
3e4b3e1f
JL		 1187 vol->cred_uid = current_uid();
1188 vol->linux_uid = current_uid();
a001e5b5 1189 vol->linux_gid = current_gid();
f55ed1a8
JL		 1190
1191 /* default to only allowing write access to owner of the mount */
1192 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1da177e4
LT		 1193
1194 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
ac67055e
JA		 1195 /* default is always to request posix paths. */
1196 vol->posix_paths = 1;
a0c9217f
JL		 1197 /* default to using server inode numbers where available */
1198 vol->server_ino = 1;
ac67055e 1199
1b359204
JL		 1200 /* default is to use strict cifs caching semantics */
1201 vol->strict_io = true;
1202
6d20e840
SJ		 1203 vol->actimeo = CIFS_DEF_ACTIMEO;
1204
23db65f5
JL		 1205 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1206 vol->ops = &smb1_operations;
1207 vol->vals = &smb1_values;
1208
b946845a
SF		 1209 if (!mountdata)
1210 goto cifs_parse_mount_err;
1211
1212 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1213 if (!mountdata_copy)
1214 goto cifs_parse_mount_err;
1da177e4 1215
b946845a 1216 options = mountdata_copy;
4906e50b 1217 end = options + strlen(options);
8830d7e0 1218
50c2f753 1219 if (strncmp(options, "sep=", 4) == 0) {
fb8c4b14 1220 if (options[4] != 0) {
1da177e4
LT		 1221 separator[0] = options[4];
1222 options += 5;
1223 } else {
b6b38f70 1224 cFYI(1, "Null separator not allowed");
1da177e4
LT		 1225 }
1226 }
3d3ea8e6
SP		 1227 vol->backupuid_specified = false; /* no backup intent for a user */
1228 vol->backupgid_specified = false; /* no backup intent for a group */
50c2f753 1229
d387a5c5
JL		 1230 /*
1231 * For now, we ignore -EINVAL errors under the assumption that the
1232 * unc= and prefixpath= options will be usable.
1233 */
1234 if (cifs_parse_devname(devname, vol) == -ENOMEM) {
1235 printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
1236 "device string.\n");
1237 goto out_nomem;
1238 }
1239
1da177e4 1240 while ((data = strsep(&options, separator)) != NULL) {
8830d7e0
SP		 1241 substring_t args[MAX_OPT_ARGS];
1242 unsigned long option;
1243 int token;
1244
1da177e4
LT		 1245 if (!*data)
1246 continue;
1da177e4 1247
8830d7e0
SP		 1248 token = match_token(data, cifs_mount_option_tokens, args);
1249
1250 switch (token) {
1251
1252 /* Ingnore the following */
1253 case Opt_ignore:
1254 break;
1255
1256 /* Boolean values */
1257 case Opt_user_xattr:
1da177e4 1258 vol->no_xattr = 0;
8830d7e0
SP		 1259 break;
1260 case Opt_nouser_xattr:
1da177e4 1261 vol->no_xattr = 1;
8830d7e0
SP		 1262 break;
1263 case Opt_forceuid:
9b9d6b24 1264 override_uid = 1;
8830d7e0
SP		 1265 break;
1266 case Opt_noforceuid:
9b9d6b24 1267 override_uid = 0;
8830d7e0 1268 break;
72bd481f
JL		 1269 case Opt_forcegid:
1270 override_gid = 1;
1271 break;
1272 case Opt_noforcegid:
1273 override_gid = 0;
1274 break;
8830d7e0 1275 case Opt_noblocksend:
edf1ae40 1276 vol->noblocksnd = 1;
8830d7e0
SP		 1277 break;
1278 case Opt_noautotune:
edf1ae40 1279 vol->noautotune = 1;
8830d7e0
SP		 1280 break;
1281 case Opt_hard:
1da177e4 1282 vol->retry = 1;
8830d7e0
SP		 1283 break;
1284 case Opt_soft:
1da177e4 1285 vol->retry = 0;
8830d7e0
SP		 1286 break;
1287 case Opt_perm:
1da177e4 1288 vol->noperm = 0;
8830d7e0
SP		 1289 break;
1290 case Opt_noperm:
1da177e4 1291 vol->noperm = 1;
8830d7e0
SP		 1292 break;
1293 case Opt_mapchars:
6a0b4824 1294 vol->remap = 1;
8830d7e0
SP		 1295 break;
1296 case Opt_nomapchars:
6a0b4824 1297 vol->remap = 0;
8830d7e0
SP		 1298 break;
1299 case Opt_sfu:
50c2f753 1300 vol->sfu_emul = 1;
8830d7e0
SP		 1301 break;
1302 case Opt_nosfu:
50c2f753 1303 vol->sfu_emul = 0;
8830d7e0
SP		 1304 break;
1305 case Opt_nodfs:
2c1b8615 1306 vol->nodfs = 1;
8830d7e0
SP		 1307 break;
1308 case Opt_posixpaths:
ac67055e 1309 vol->posix_paths = 1;
8830d7e0
SP		 1310 break;
1311 case Opt_noposixpaths:
ac67055e 1312 vol->posix_paths = 0;
8830d7e0
SP		 1313 break;
1314 case Opt_nounix:
c18c842b 1315 vol->no_linux_ext = 1;
8830d7e0
SP		 1316 break;
1317 case Opt_nocase:
50c2f753 1318 vol->nocase = 1;
8830d7e0
SP		 1319 break;
1320 case Opt_brl:
c46fa8ac 1321 vol->nobrl = 0;
8830d7e0
SP		 1322 break;
1323 case Opt_nobrl:
c46fa8ac 1324 vol->nobrl = 1;
5cfdddcf
PS		 1325 /*
1326 * turn off mandatory locking in mode
8830d7e0 1327 * if remote locking is turned off since the
5cfdddcf
PS		 1328 * local vfs will do advisory
1329 */
50c2f753
SF		 1330 if (vol->file_mode ==
1331 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
d3485d37 1332 vol->file_mode = S_IALLUGO;
8830d7e0
SP		 1333 break;
1334 case Opt_forcemandatorylock:
13a6e42a 1335 vol->mand_lock = 1;
8830d7e0
SP		 1336 break;
1337 case Opt_setuids:
1da177e4 1338 vol->setuids = 1;
8830d7e0
SP		 1339 break;
1340 case Opt_nosetuids:
1da177e4 1341 vol->setuids = 0;
8830d7e0
SP		 1342 break;
1343 case Opt_dynperm:
d0a9c078 1344 vol->dynperm = true;
8830d7e0
SP		 1345 break;
1346 case Opt_nodynperm:
d0a9c078 1347 vol->dynperm = false;
8830d7e0
SP		 1348 break;
1349 case Opt_nohard:
1da177e4 1350 vol->retry = 0;
8830d7e0
SP		 1351 break;
1352 case Opt_nosoft:
1da177e4 1353 vol->retry = 1;
8830d7e0
SP		 1354 break;
1355 case Opt_nointr:
1da177e4 1356 vol->intr = 0;
8830d7e0
SP		 1357 break;
1358 case Opt_intr:
1da177e4 1359 vol->intr = 1;
8830d7e0
SP		 1360 break;
1361 case Opt_nostrictsync:
be652445 1362 vol->nostrictsync = 1;
8830d7e0
SP		 1363 break;
1364 case Opt_strictsync:
be652445 1365 vol->nostrictsync = 0;
8830d7e0
SP		 1366 break;
1367 case Opt_serverino:
1da177e4 1368 vol->server_ino = 1;
8830d7e0
SP		 1369 break;
1370 case Opt_noserverino:
1da177e4 1371 vol->server_ino = 0;
8830d7e0
SP		 1372 break;
1373 case Opt_rwpidforward:
d4ffff1f 1374 vol->rwpidforward = 1;
8830d7e0
SP		 1375 break;
1376 case Opt_cifsacl:
0a4b92c0 1377 vol->cifs_acl = 1;
8830d7e0
SP		 1378 break;
1379 case Opt_nocifsacl:
0a4b92c0 1380 vol->cifs_acl = 0;
8830d7e0
SP		 1381 break;
1382 case Opt_acl:
1da177e4 1383 vol->no_psx_acl = 0;
8830d7e0
SP		 1384 break;
1385 case Opt_noacl:
1da177e4 1386 vol->no_psx_acl = 1;
8830d7e0
SP		 1387 break;
1388 case Opt_locallease:
84210e91 1389 vol->local_lease = 1;
8830d7e0
SP		 1390 break;
1391 case Opt_sign:
750d1151 1392 vol->secFlg |= CIFSSEC_MUST_SIGN;
8830d7e0
SP		 1393 break;
1394 case Opt_seal:
95b1cb90 1395 /* we do not do the following in secFlags because seal
8830d7e0
SP		 1396 * is a per tree connection (mount) not a per socket
1397 * or per-smb connection option in the protocol
1398 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1399 */
95b1cb90 1400 vol->seal = 1;
8830d7e0 1401 break;
8830d7e0 1402 case Opt_noac:
50c2f753
SF		 1403 printk(KERN_WARNING "CIFS: Mount option noac not "
1404 "supported. Instead set "
1405 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
8830d7e0
SP		 1406 break;
1407 case Opt_fsc:
607a569d 1408#ifndef CONFIG_CIFS_FSCACHE
83fb086e 1409 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
607a569d 1410 "kernel config option set");
b946845a 1411 goto cifs_parse_mount_err;
607a569d 1412#endif
fa1df75d 1413 vol->fsc = true;
8830d7e0
SP		 1414 break;
1415 case Opt_mfsymlinks:
736a3320 1416 vol->mfsymlinks = true;
8830d7e0
SP		 1417 break;
1418 case Opt_multiuser:
0eb8a132 1419 vol->multiuser = true;
8830d7e0 1420 break;
d8162558
JL		 1421 case Opt_sloppy:
1422 sloppy = true;
1423 break;
8830d7e0
SP		 1424
1425 /* Numeric Values */
1426 case Opt_backupuid:
1427 if (get_option_ul(args, &option)) {
3d3ea8e6
SP		 1428 cERROR(1, "%s: Invalid backupuid value",
1429 __func__);
1430 goto cifs_parse_mount_err;
1431 }
8830d7e0 1432 vol->backupuid = option;
3d3ea8e6 1433 vol->backupuid_specified = true;
8830d7e0
SP		 1434 break;
1435 case Opt_backupgid:
1436 if (get_option_ul(args, &option)) {
3d3ea8e6
SP		 1437 cERROR(1, "%s: Invalid backupgid value",
1438 __func__);
1439 goto cifs_parse_mount_err;
1440 }
8830d7e0 1441 vol->backupgid = option;
3d3ea8e6 1442 vol->backupgid_specified = true;
8830d7e0
SP		 1443 break;
1444 case Opt_uid:
1445 if (get_option_ul(args, &option)) {
1446 cERROR(1, "%s: Invalid uid value",
1447 __func__);
1448 goto cifs_parse_mount_err;
1449 }
1450 vol->linux_uid = option;
1451 uid_specified = true;
1452 break;
1453 case Opt_cruid:
1454 if (get_option_ul(args, &option)) {
1455 cERROR(1, "%s: Invalid cruid value",
1456 __func__);
1457 goto cifs_parse_mount_err;
1458 }
1459 vol->cred_uid = option;
1460 break;
1461 case Opt_gid:
1462 if (get_option_ul(args, &option)) {
1463 cERROR(1, "%s: Invalid gid value",
1464 __func__);
1465 goto cifs_parse_mount_err;
1466 }
1467 vol->linux_gid = option;
1468 gid_specified = true;
1469 break;
1470 case Opt_file_mode:
1471 if (get_option_ul(args, &option)) {
1472 cERROR(1, "%s: Invalid file_mode value",
1473 __func__);
1474 goto cifs_parse_mount_err;
1475 }
1476 vol->file_mode = option;
1477 break;
1478 case Opt_dirmode:
1479 if (get_option_ul(args, &option)) {
1480 cERROR(1, "%s: Invalid dir_mode value",
1481 __func__);
1482 goto cifs_parse_mount_err;
1483 }
1484 vol->dir_mode = option;
1485 break;
1486 case Opt_port:
b979aaa1
JL		 1487 if (get_option_ul(args, &option) ||
1488 option > USHRT_MAX) {
1489 cERROR(1, "%s: Invalid port value", __func__);
8830d7e0
SP		 1490 goto cifs_parse_mount_err;
1491 }
b979aaa1 1492 port = (unsigned short)option;
8830d7e0
SP		 1493 break;
1494 case Opt_rsize:
1495 if (get_option_ul(args, &option)) {
1496 cERROR(1, "%s: Invalid rsize value",
1497 __func__);
b946845a 1498 goto cifs_parse_mount_err;
8830d7e0
SP		 1499 }
1500 vol->rsize = option;
1501 break;
1502 case Opt_wsize:
1503 if (get_option_ul(args, &option)) {
1504 cERROR(1, "%s: Invalid wsize value",
1505 __func__);
1506 goto cifs_parse_mount_err;
1507 }
1508 vol->wsize = option;
1509 break;
1510 case Opt_actimeo:
1511 if (get_option_ul(args, &option)) {
1512 cERROR(1, "%s: Invalid actimeo value",
1513 __func__);
1514 goto cifs_parse_mount_err;
1515 }
1516 vol->actimeo = HZ * option;
1517 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1518 cERROR(1, "CIFS: attribute cache"
1519 "timeout too large");
1520 goto cifs_parse_mount_err;
1521 }
1522 break;
1523
1524 /* String Arguments */
1525
4fe9e963
SP		 1526 case Opt_blank_user:
1527 /* null user, ie. anonymous authentication */
1528 vol->nullauth = 1;
1529 vol->username = NULL;
1530 break;
8830d7e0
SP		 1531 case Opt_user:
1532 string = match_strdup(args);
1533 if (string == NULL)
1534 goto out_nomem;
1535
4fe9e963 1536 if (strnlen(string, MAX_USERNAME_SIZE) >
8830d7e0
SP		 1537 MAX_USERNAME_SIZE) {
1538 printk(KERN_WARNING "CIFS: username too long\n");
1539 goto cifs_parse_mount_err;
1540 }
1541 vol->username = kstrdup(string, GFP_KERNEL);
1542 if (!vol->username) {
1543 printk(KERN_WARNING "CIFS: no memory "
1544 "for username\n");
1545 goto cifs_parse_mount_err;
1546 }
1547 break;
1548 case Opt_blank_pass:
1549 vol->password = NULL;
1550 break;
1551 case Opt_pass:
1552 /* passwords have to be handled differently
1553 * to allow the character used for deliminator
1554 * to be passed within them
1555 */
1556
1557 /* Obtain the value string */
1558 value = strchr(data, '=');
10238074 1559 value++;
8830d7e0
SP		 1560
1561 /* Set tmp_end to end of the string */
1562 tmp_end = (char *) value + strlen(value);
1563
1564 /* Check if following character is the deliminator
1565 * If yes, we have encountered a double deliminator
1566 * reset the NULL character to the deliminator
1567 */
e73f843a 1568 if (tmp_end < end && tmp_end[1] == delim) {
8830d7e0
SP		 1569 tmp_end[0] = delim;
1570
e73f843a
SJ		 1571 /* Keep iterating until we get to a single
1572 * deliminator OR the end
1573 */
1574 while ((tmp_end = strchr(tmp_end, delim))
1575 != NULL && (tmp_end[1] == delim)) {
1576 tmp_end = (char *) &tmp_end[2];
1577 }
1578
1579 /* Reset var options to point to next element */
1580 if (tmp_end) {
1581 tmp_end[0] = '\0';
1582 options = (char *) &tmp_end[1];
1583 } else
1584 /* Reached the end of the mount option
1585 * string */
1586 options = end;
8830d7e0
SP		 1587 }
1588
8830d7e0
SP		 1589 /* Now build new password string */
1590 temp_len = strlen(value);
1591 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1592 if (vol->password == NULL) {
1593 printk(KERN_WARNING "CIFS: no memory "
1594 "for password\n");
1595 goto cifs_parse_mount_err;
1596 }
1597
1598 for (i = 0, j = 0; i < temp_len; i++, j++) {
1599 vol->password[j] = value[i];
1600 if ((value[i] == delim) &&
1601 value[i+1] == delim)
1602 /* skip the second deliminator */
1603 i++;
1604 }
1605 vol->password[j] = '\0';
1606 break;
4fe9e963 1607 case Opt_blank_ip:
b979aaa1
JL		 1608 /* FIXME: should this be an error instead? */
1609 got_ip = false;
4fe9e963 1610 break;
8830d7e0
SP		 1611 case Opt_ip:
1612 string = match_strdup(args);
1613 if (string == NULL)
1614 goto out_nomem;
1615
b979aaa1
JL		 1616 if (!cifs_convert_address(dstaddr, string,
1617 strlen(string))) {
1618 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1619 string);
8830d7e0
SP		 1620 goto cifs_parse_mount_err;
1621 }
b979aaa1 1622 got_ip = true;
8830d7e0
SP		 1623 break;
1624 case Opt_unc:
d387a5c5 1625 string = vol->UNC;
62a1a439 1626 vol->UNC = match_strdup(args);
8367224b 1627 if (vol->UNC == NULL)
8830d7e0
SP		 1628 goto out_nomem;
1629
62a1a439
JL		 1630 convert_delimiter(vol->UNC, '\\');
1631 if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
d387a5c5 1632 printk(KERN_ERR "CIFS: UNC Path does not "
62a1a439 1633 "begin with // or \\\\\n");
b946845a 1634 goto cifs_parse_mount_err;
1da177e4 1635 }
8830d7e0 1636
d387a5c5
JL		 1637 /* Compare old unc= option to new one */
1638 if (!string || strcmp(string, vol->UNC))
1639 printk(KERN_WARNING "CIFS: the value of the "
1640 "unc= mount option does not match the "
1641 "device string. Using the unc= option "
1642 "for now. In 3.10, that option will "
1643 "be ignored and the contents of the "
1644 "device string will be used "
1645 "instead. (%s != %s)\n", string,
1646 vol->UNC);
8830d7e0
SP		 1647 break;
1648 case Opt_domain:
1649 string = match_strdup(args);
1650 if (string == NULL)
1651 goto out_nomem;
1652
4fe9e963 1653 if (strnlen(string, 256) == 256) {
8830d7e0
SP		 1654 printk(KERN_WARNING "CIFS: domain name too"
1655 " long\n");
1656 goto cifs_parse_mount_err;
1657 }
1658
1659 vol->domainname = kstrdup(string, GFP_KERNEL);
1660 if (!vol->domainname) {
1661 printk(KERN_WARNING "CIFS: no memory "
1662 "for domainname\n");
1663 goto cifs_parse_mount_err;
1664 }
1665 cFYI(1, "Domain name set");
1666 break;
1667 case Opt_srcaddr:
1668 string = match_strdup(args);
1669 if (string == NULL)
1670 goto out_nomem;
1671
4fe9e963 1672 if (!cifs_convert_address(
8830d7e0
SP		 1673 (struct sockaddr *)&vol->srcaddr,
1674 string, strlen(string))) {
1675 printk(KERN_WARNING "CIFS: Could not parse"
1676 " srcaddr: %s\n", string);
1677 goto cifs_parse_mount_err;
1678 }
1679 break;
1680 case Opt_prefixpath:
839db3d1
JL		 1681 /* skip over any leading delimiter */
1682 if (*args[0].from == '/' || *args[0].from == '\\')
1683 args[0].from++;
8830d7e0 1684
d387a5c5 1685 string = vol->prepath;
839db3d1 1686 vol->prepath = match_strdup(args);
8367224b 1687 if (vol->prepath == NULL)
839db3d1 1688 goto out_nomem;
d387a5c5
JL		 1689 /* Compare old prefixpath= option to new one */
1690 if (!string || strcmp(string, vol->prepath))
1691 printk(KERN_WARNING "CIFS: the value of the "
1692 "prefixpath= mount option does not "
1693 "match the device string. Using the "
1694 "prefixpath= option for now. In 3.10, "
1695 "that option will be ignored and the "
1696 "contents of the device string will be "
1697 "used instead.(%s != %s)\n", string,
1698 vol->prepath);
8830d7e0
SP		 1699 break;
1700 case Opt_iocharset:
1701 string = match_strdup(args);
1702 if (string == NULL)
1703 goto out_nomem;
1704
4fe9e963 1705 if (strnlen(string, 1024) >= 65) {
8830d7e0
SP		 1706 printk(KERN_WARNING "CIFS: iocharset name "
1707 "too long.\n");
1708 goto cifs_parse_mount_err;
1709 }
1710
1711 if (strnicmp(string, "default", 7) != 0) {
1712 vol->iocharset = kstrdup(string,
1713 GFP_KERNEL);
1714 if (!vol->iocharset) {
1715 printk(KERN_WARNING "CIFS: no memory"
1716 "for charset\n");
1717 goto cifs_parse_mount_err;
1718 }
1719 }
1720 /* if iocharset not set then load_nls_default
1721 * is used by caller
1722 */
1723 cFYI(1, "iocharset set to %s", string);
1724 break;
1725 case Opt_sockopt:
1726 string = match_strdup(args);
1727 if (string == NULL)
1728 goto out_nomem;
1729
67c1f529
JL		 1730 if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1731 printk(KERN_WARNING "CIFS: the "
1732 "sockopt=TCP_NODELAY option has been "
1733 "deprecated and will be removed "
1734 "in 3.9\n");
8830d7e0 1735 vol->sockopt_tcp_nodelay = 1;
67c1f529 1736 }
8830d7e0
SP		 1737 break;
1738 case Opt_netbiosname:
1739 string = match_strdup(args);
1740 if (string == NULL)
1741 goto out_nomem;
1742
8830d7e0
SP		 1743 memset(vol->source_rfc1001_name, 0x20,
1744 RFC1001_NAME_LEN);
1745 /*
1746 * FIXME: are there cases in which a comma can
1747 * be valid in workstation netbios name (and
1748 * need special handling)?
1749 */
1750 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1751 /* don't ucase netbiosname for user */
1752 if (string[i] == 0)
1753 break;
1754 vol->source_rfc1001_name[i] = string[i];
1755 }
1756 /* The string has 16th byte zero still from
1757 * set at top of the function
1758 */
1759 if (i == RFC1001_NAME_LEN && string[i] != 0)
1760 printk(KERN_WARNING "CIFS: netbiosname"
1761 " longer than 15 truncated.\n");
1762
1763 break;
1764 case Opt_servern:
1765 /* servernetbiosname specified override *SMBSERVER */
1766 string = match_strdup(args);
1767 if (string == NULL)
1768 goto out_nomem;
1769
8830d7e0
SP		 1770 /* last byte, type, is 0x20 for servr type */
1771 memset(vol->target_rfc1001_name, 0x20,
1772 RFC1001_NAME_LEN_WITH_NULL);
1773
1774 /* BB are there cases in which a comma can be
1775 valid in this workstation netbios name
1776 (and need special handling)? */
1777
1778 /* user or mount helper must uppercase the
1779 netbios name */
1780 for (i = 0; i < 15; i++) {
1781 if (string[i] == 0)
1782 break;
1783 vol->target_rfc1001_name[i] = string[i];
1784 }
1785 /* The string has 16th byte zero still from
1786 set at top of the function */
1787 if (i == RFC1001_NAME_LEN && string[i] != 0)
1788 printk(KERN_WARNING "CIFS: server net"
1789 "biosname longer than 15 truncated.\n");
1790 break;
1791 case Opt_ver:
1792 string = match_strdup(args);
1793 if (string == NULL)
1794 goto out_nomem;
1795
5249af32 1796 if (strnicmp(string, "1", 1) == 0) {
8830d7e0
SP		 1797 /* This is the default */
1798 break;
1799 }
1800 /* For all other value, error */
1801 printk(KERN_WARNING "CIFS: Invalid version"
1802 " specified\n");
b946845a 1803 goto cifs_parse_mount_err;
23db65f5
JL		 1804 case Opt_vers:
1805 string = match_strdup(args);
1806 if (string == NULL)
1807 goto out_nomem;
1808
1809 if (cifs_parse_smb_version(string, vol) != 0)
1810 goto cifs_parse_mount_err;
1811 break;
8830d7e0
SP		 1812 case Opt_sec:
1813 string = match_strdup(args);
1814 if (string == NULL)
1815 goto out_nomem;
1816
8830d7e0
SP		 1817 if (cifs_parse_security_flavors(string, vol) != 0)
1818 goto cifs_parse_mount_err;
1819 break;
15b6a473
JL		 1820 case Opt_cache:
1821 string = match_strdup(args);
1822 if (string == NULL)
1823 goto out_nomem;
1824
1825 if (cifs_parse_cache_flavor(string, vol) != 0)
1826 goto cifs_parse_mount_err;
1827 break;
8830d7e0 1828 default:
d8162558
JL		 1829 /*
1830 * An option we don't recognize. Save it off for later
1831 * if we haven't already found one
1832 */
1833 if (!invalid)
1834 invalid = data;
8830d7e0 1835 break;
1da177e4 1836 }
8830d7e0
SP		 1837 /* Free up any allocated string */
1838 kfree(string);
1839 string = NULL;
1da177e4 1840 }
0eb8a132 1841
d8162558
JL		 1842 if (!sloppy && invalid) {
1843 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1844 goto cifs_parse_mount_err;
1845 }
1846
8a8798a5
JL		 1847#ifndef CONFIG_KEYS
1848 /* Muliuser mounts require CONFIG_KEYS support */
1849 if (vol->multiuser) {
1850 cERROR(1, "Multiuser mounts require kernels with "
1851 "CONFIG_KEYS enabled.");
b946845a 1852 goto cifs_parse_mount_err;
0eb8a132 1853 }
8a8798a5 1854#endif
e5e69abd 1855 if (!vol->UNC) {
d387a5c5
JL		 1856 cERROR(1, "CIFS mount error: No usable UNC path provided in "
1857 "device string or in unc= option!");
e5e69abd
JL		 1858 goto cifs_parse_mount_err;
1859 }
0eb8a132 1860
62a1a439
JL		 1861 /* make sure UNC has a share name */
1862 if (!strchr(vol->UNC + 3, '\\')) {
1863 cERROR(1, "Malformed UNC. Unable to find share name.");
1864 goto cifs_parse_mount_err;
1865 }
1866
b979aaa1
JL		 1867 if (!got_ip) {
1868 /* No ip= option specified? Try to get it from UNC */
1869 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1870 strlen(&vol->UNC[2]))) {
1871 printk(KERN_ERR "Unable to determine destination "
1872 "address.\n");
1873 goto cifs_parse_mount_err;
1874 }
1875 }
1876
1877 /* set the port that we got earlier */
1878 cifs_set_port(dstaddr, port);
1da177e4 1879
9b9d6b24
JL		 1880 if (uid_specified)
1881 vol->override_uid = override_uid;
1882 else if (override_uid == 1)
1883 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1884 "specified with no uid= option.\n");
1885
1886 if (gid_specified)
1887 vol->override_gid = override_gid;
1888 else if (override_gid == 1)
1889 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1890 "specified with no gid= option.\n");
1891
b946845a 1892 kfree(mountdata_copy);
1da177e4 1893 return 0;
b946845a 1894
8830d7e0
SP		 1895out_nomem:
1896 printk(KERN_WARNING "Could not allocate temporary buffer\n");
b946845a 1897cifs_parse_mount_err:
8830d7e0 1898 kfree(string);
b946845a
SF		 1899 kfree(mountdata_copy);
1900 return 1;
1da177e4
LT		 1901}
1902
3eb9a889
BG		 1903/** Returns true if srcaddr isn't specified and rhs isn't
1904 * specified, or if srcaddr is specified and
1905 * matches the IP address of the rhs argument.
1906 */
1907static bool
1908srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1909{
1910 switch (srcaddr->sa_family) {
1911 case AF_UNSPEC:
1912 return (rhs->sa_family == AF_UNSPEC);
1913 case AF_INET: {
1914 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1915 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1916 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1917 }
1918 case AF_INET6: {
1919 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
e3e2775c 1920 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
3eb9a889
BG		 1921 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1922 }
1923 default:
1924 WARN_ON(1);
1925 return false; /* don't expect to be here */
1926 }
1927}
1928
4b886136
PS		 1929/*
1930 * If no port is specified in addr structure, we try to match with 445 port
1931 * and if it fails - with 139 ports. It should be called only if address
1932 * families of server and addr are equal.
1933 */
1934static bool
1935match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1936{
6da97910 1937 __be16 port, *sport;
4b886136
PS		 1938
1939 switch (addr->sa_family) {
1940 case AF_INET:
1941 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1942 port = ((struct sockaddr_in *) addr)->sin_port;
1943 break;
1944 case AF_INET6:
1945 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1946 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1947 break;
1948 default:
1949 WARN_ON(1);
1950 return false;
1951 }
1952
1953 if (!port) {
1954 port = htons(CIFS_PORT);
1955 if (port == *sport)
1956 return true;
1957
1958 port = htons(RFC1001_PORT);
1959 }
1960
1961 return port == *sport;
1962}
3eb9a889 1963
4515148e 1964static bool
3eb9a889
BG		 1965match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1966 struct sockaddr *srcaddr)
4515148e 1967{
4515148e 1968 switch (addr->sa_family) {
a9f1b85e
PS		 1969 case AF_INET: {
1970 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1971 struct sockaddr_in *srv_addr4 =
1972 (struct sockaddr_in *)&server->dstaddr;
1973
1974 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
4515148e 1975 return false;
4515148e 1976 break;
a9f1b85e
PS		 1977 }
1978 case AF_INET6: {
1979 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1980 struct sockaddr_in6 *srv_addr6 =
1981 (struct sockaddr_in6 *)&server->dstaddr;
1982
4515148e 1983 if (!ipv6_addr_equal(&addr6->sin6_addr,
a9f1b85e 1984 &srv_addr6->sin6_addr))
4515148e 1985 return false;
a9f1b85e 1986 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
4515148e 1987 return false;
4515148e
JL		 1988 break;
1989 }
a9f1b85e
PS		 1990 default:
1991 WARN_ON(1);
1992 return false; /* don't expect to be here */
1993 }
4515148e 1994
3eb9a889
BG		 1995 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1996 return false;
1997
4515148e
JL		 1998 return true;
1999}
2000
daf5b0b6
JL		 2001static bool
2002match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2003{
2004 unsigned int secFlags;
2005
2006 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2007 secFlags = vol->secFlg;
2008 else
2009 secFlags = global_secflags | vol->secFlg;
2010
2011 switch (server->secType) {
2012 case LANMAN:
2013 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2014 return false;
2015 break;
2016 case NTLMv2:
2017 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2018 return false;
2019 break;
2020 case NTLM:
2021 if (!(secFlags & CIFSSEC_MAY_NTLM))
2022 return false;
2023 break;
2024 case Kerberos:
2025 if (!(secFlags & CIFSSEC_MAY_KRB5))
2026 return false;
2027 break;
2028 case RawNTLMSSP:
2029 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2030 return false;
2031 break;
2032 default:
2033 /* shouldn't happen */
2034 return false;
2035 }
2036
25985edc 2037 /* now check if signing mode is acceptable */
daf5b0b6 2038 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
96daf2b0 2039 (server->sec_mode & SECMODE_SIGN_REQUIRED))
daf5b0b6
JL		 2040 return false;
2041 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
96daf2b0 2042 (server->sec_mode &
daf5b0b6
JL		 2043 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2044 return false;
2045
2046 return true;
2047}
2048
9fa114f7 2049static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
37bb04e5 2050{
9fa114f7
JL		 2051 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2052
23db65f5
JL		 2053 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2054 return 0;
2055
37bb04e5
PS		 2056 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2057 return 0;
2058
2059 if (!match_address(server, addr,
2060 (struct sockaddr *)&vol->srcaddr))
2061 return 0;
2062
2063 if (!match_port(server, addr))
2064 return 0;
2065
2066 if (!match_security(server, vol))
2067 return 0;
2068
2069 return 1;
2070}
2071
e7ddee90 2072static struct TCP_Server_Info *
9fa114f7 2073cifs_find_tcp_session(struct smb_vol *vol)
1da177e4 2074{
e7ddee90 2075 struct TCP_Server_Info *server;
e7ddee90 2076
3f9bcca7 2077 spin_lock(&cifs_tcp_ses_lock);
4515148e 2078 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
9fa114f7 2079 if (!match_server(server, vol))
daf5b0b6
JL		 2080 continue;
2081
e7ddee90 2082 ++server->srv_count;
3f9bcca7 2083 spin_unlock(&cifs_tcp_ses_lock);
b6b38f70 2084 cFYI(1, "Existing tcp session with server found");
e7ddee90 2085 return server;
1da177e4 2086 }
3f9bcca7 2087 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2088 return NULL;
2089}
1b20d672 2090
14fbf50d 2091static void
e7ddee90 2092cifs_put_tcp_session(struct TCP_Server_Info *server)
1da177e4 2093{
e7ddee90 2094 struct task_struct *task;
1b20d672 2095
3f9bcca7 2096 spin_lock(&cifs_tcp_ses_lock);
e7ddee90 2097 if (--server->srv_count > 0) {
3f9bcca7 2098 spin_unlock(&cifs_tcp_ses_lock);
e7ddee90 2099 return;
1da177e4 2100 }
1b20d672 2101
f1d0c998
RL		 2102 put_net(cifs_net_ns(server));
2103
e7ddee90 2104 list_del_init(&server->tcp_ses_list);
3f9bcca7 2105 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2106
c74093b6
JL		 2107 cancel_delayed_work_sync(&server->echo);
2108
e7ddee90
JL		 2109 spin_lock(&GlobalMid_Lock);
2110 server->tcpStatus = CifsExiting;
2111 spin_unlock(&GlobalMid_Lock);
dea570e0 2112
d2b91521 2113 cifs_crypto_shash_release(server);
488f1d2d
SJ		 2114 cifs_fscache_release_client_cookie(server);
2115
21e73393
SP		 2116 kfree(server->session_key.response);
2117 server->session_key.response = NULL;
2118 server->session_key.len = 0;
2119
e7ddee90
JL		 2120 task = xchg(&server->tsk, NULL);
2121 if (task)
2122 force_sig(SIGKILL, task);
1da177e4
LT		 2123}
2124
63c038c2
JL		 2125static struct TCP_Server_Info *
2126cifs_get_tcp_session(struct smb_vol *volume_info)
2127{
2128 struct TCP_Server_Info *tcp_ses = NULL;
63c038c2
JL		 2129 int rc;
2130
b979aaa1 2131 cFYI(1, "UNC: %s", volume_info->UNC);
63c038c2
JL		 2132
2133 /* see if we already have a matching tcp_ses */
9fa114f7 2134 tcp_ses = cifs_find_tcp_session(volume_info);
63c038c2
JL		 2135 if (tcp_ses)
2136 return tcp_ses;
2137
2138 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2139 if (!tcp_ses) {
2140 rc = -ENOMEM;
2141 goto out_err;
2142 }
2143
d2b91521
SP		 2144 rc = cifs_crypto_shash_allocate(tcp_ses);
2145 if (rc) {
2146 cERROR(1, "could not setup hash structures rc %d", rc);
2147 goto out_err;
2148 }
2149
23db65f5
JL		 2150 tcp_ses->ops = volume_info->ops;
2151 tcp_ses->vals = volume_info->vals;
f1d0c998 2152 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
63c038c2
JL		 2153 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2154 if (IS_ERR(tcp_ses->hostname)) {
2155 rc = PTR_ERR(tcp_ses->hostname);
f7c5445a 2156 goto out_err_crypto_release;
63c038c2
JL		 2157 }
2158
2159 tcp_ses->noblocksnd = volume_info->noblocksnd;
2160 tcp_ses->noautotune = volume_info->noautotune;
6a5fa236 2161 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
fc40f9cf 2162 tcp_ses->in_flight = 0;
2d86dbc9 2163 tcp_ses->credits = 1;
63c038c2
JL		 2164 init_waitqueue_head(&tcp_ses->response_q);
2165 init_waitqueue_head(&tcp_ses->request_q);
2166 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2167 mutex_init(&tcp_ses->srv_mutex);
2168 memcpy(tcp_ses->workstation_RFC1001_name,
2169 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2170 memcpy(tcp_ses->server_RFC1001_name,
2171 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
5d0d2882 2172 tcp_ses->session_estab = false;
63c038c2 2173 tcp_ses->sequence_number = 0;
fda35943 2174 tcp_ses->lstrp = jiffies;
58fa015f 2175 spin_lock_init(&tcp_ses->req_lock);
63c038c2
JL		 2176 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2177 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
c74093b6 2178 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
9fa114f7
JL		 2179 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2180 sizeof(tcp_ses->srcaddr));
2181 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2182 sizeof(tcp_ses->dstaddr));
63c038c2
JL		 2183 /*
2184 * at this point we are the only ones with the pointer
2185 * to the struct since the kernel thread not created yet
2186 * no need to spinlock this init of tcpStatus or srv_count
2187 */
2188 tcp_ses->tcpStatus = CifsNew;
2189 ++tcp_ses->srv_count;
2190
a9f1b85e 2191 rc = ip_connect(tcp_ses);
63c038c2 2192 if (rc < 0) {
b6b38f70 2193 cERROR(1, "Error connecting to socket. Aborting operation");
f7c5445a 2194 goto out_err_crypto_release;
63c038c2
JL		 2195 }
2196
2197 /*
2198 * since we're in a cifs function already, we know that
2199 * this will succeed. No need for try_module_get().
2200 */
2201 __module_get(THIS_MODULE);
7c97c200 2202 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
63c038c2
JL		 2203 tcp_ses, "cifsd");
2204 if (IS_ERR(tcp_ses->tsk)) {
2205 rc = PTR_ERR(tcp_ses->tsk);
b6b38f70 2206 cERROR(1, "error %d create cifsd thread", rc);
63c038c2 2207 module_put(THIS_MODULE);
f7c5445a 2208 goto out_err_crypto_release;
63c038c2 2209 }
fd88ce93 2210 tcp_ses->tcpStatus = CifsNeedNegotiate;
63c038c2
JL		 2211
2212 /* thread spawned, put it on the list */
3f9bcca7 2213 spin_lock(&cifs_tcp_ses_lock);
63c038c2 2214 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
3f9bcca7 2215 spin_unlock(&cifs_tcp_ses_lock);
63c038c2 2216
488f1d2d
SJ		 2217 cifs_fscache_get_client_cookie(tcp_ses);
2218
c74093b6 2219 /* queue echo request delayed work */
da472fc8 2220 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
c74093b6 2221
63c038c2
JL		 2222 return tcp_ses;
2223
f7c5445a 2224out_err_crypto_release:
d2b91521
SP		 2225 cifs_crypto_shash_release(tcp_ses);
2226
f1d0c998
RL		 2227 put_net(cifs_net_ns(tcp_ses));
2228
63c038c2
JL		 2229out_err:
2230 if (tcp_ses) {
8347a5cd
SF		 2231 if (!IS_ERR(tcp_ses->hostname))
2232 kfree(tcp_ses->hostname);
63c038c2
JL		 2233 if (tcp_ses->ssocket)
2234 sock_release(tcp_ses->ssocket);
2235 kfree(tcp_ses);
2236 }
2237 return ERR_PTR(rc);
2238}
2239
96daf2b0 2240static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
37bb04e5
PS		 2241{
2242 switch (ses->server->secType) {
2243 case Kerberos:
2244 if (vol->cred_uid != ses->cred_uid)
2245 return 0;
2246 break;
2247 default:
04febabc
JL		 2248 /* NULL username means anonymous session */
2249 if (ses->user_name == NULL) {
2250 if (!vol->nullauth)
2251 return 0;
2252 break;
2253 }
2254
37bb04e5 2255 /* anything else takes username/password */
04febabc
JL		 2256 if (strncmp(ses->user_name,
2257 vol->username ? vol->username : "",
37bb04e5
PS		 2258 MAX_USERNAME_SIZE))
2259 return 0;
2260 if (strlen(vol->username) != 0 &&
2261 ses->password != NULL &&
2262 strncmp(ses->password,
2263 vol->password ? vol->password : "",
2264 MAX_PASSWORD_SIZE))
2265 return 0;
2266 }
2267 return 1;
2268}
2269
96daf2b0 2270static struct cifs_ses *
4ff67b72 2271cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1da177e4 2272{
96daf2b0 2273 struct cifs_ses *ses;
dea570e0 2274
3f9bcca7 2275 spin_lock(&cifs_tcp_ses_lock);
4ff67b72 2276 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
37bb04e5
PS		 2277 if (!match_session(ses, vol))
2278 continue;
14fbf50d 2279 ++ses->ses_count;
3f9bcca7 2280 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2281 return ses;
2282 }
3f9bcca7 2283 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2284 return NULL;
2285}
dea570e0 2286
14fbf50d 2287static void
96daf2b0 2288cifs_put_smb_ses(struct cifs_ses *ses)
14fbf50d 2289{
58c45c58 2290 unsigned int xid;
14fbf50d 2291 struct TCP_Server_Info *server = ses->server;
dea570e0 2292
ac3aa2f8 2293 cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
3f9bcca7 2294 spin_lock(&cifs_tcp_ses_lock);
14fbf50d 2295 if (--ses->ses_count > 0) {
3f9bcca7 2296 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 2297 return;
2298 }
dea570e0 2299
14fbf50d 2300 list_del_init(&ses->smb_ses_list);
3f9bcca7 2301 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2302
58c45c58 2303 if (ses->status == CifsGood && server->ops->logoff) {
6d5786a3 2304 xid = get_xid();
58c45c58 2305 server->ops->logoff(xid, ses);
6d5786a3 2306 _free_xid(xid);
14fbf50d
JL		 2307 }
2308 sesInfoFree(ses);
2309 cifs_put_tcp_session(server);
2310}
dea570e0 2311
8a8798a5
JL		 2312#ifdef CONFIG_KEYS
2313
2314/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2315#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2316
2317/* Populate username and pw fields from keyring if possible */
2318static int
2319cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2320{
2321 int rc = 0;
2322 char *desc, *delim, *payload;
2323 ssize_t len;
2324 struct key *key;
2325 struct TCP_Server_Info *server = ses->server;
2326 struct sockaddr_in *sa;
2327 struct sockaddr_in6 *sa6;
2328 struct user_key_payload *upayload;
2329
2330 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2331 if (!desc)
2332 return -ENOMEM;
2333
2334 /* try to find an address key first */
2335 switch (server->dstaddr.ss_family) {
2336 case AF_INET:
2337 sa = (struct sockaddr_in *)&server->dstaddr;
2338 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2339 break;
2340 case AF_INET6:
2341 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2342 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2343 break;
2344 default:
2345 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2346 rc = -EINVAL;
2347 goto out_err;
2348 }
2349
2350 cFYI(1, "%s: desc=%s", __func__, desc);
2351 key = request_key(&key_type_logon, desc, "");
2352 if (IS_ERR(key)) {
2353 if (!ses->domainName) {
2354 cFYI(1, "domainName is NULL");
2355 rc = PTR_ERR(key);
2356 goto out_err;
2357 }
2358
2359 /* didn't work, try to find a domain key */
2360 sprintf(desc, "cifs:d:%s", ses->domainName);
2361 cFYI(1, "%s: desc=%s", __func__, desc);
2362 key = request_key(&key_type_logon, desc, "");
2363 if (IS_ERR(key)) {
2364 rc = PTR_ERR(key);
2365 goto out_err;
2366 }
2367 }
2368
2369 down_read(&key->sem);
2370 upayload = key->payload.data;
2371 if (IS_ERR_OR_NULL(upayload)) {
4edc53c1 2372 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
8a8798a5
JL		 2373 goto out_key_put;
2374 }
2375
2376 /* find first : in payload */
2377 payload = (char *)upayload->data;
2378 delim = strnchr(payload, upayload->datalen, ':');
2379 cFYI(1, "payload=%s", payload);
2380 if (!delim) {
2381 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2382 upayload->datalen);
2383 rc = -EINVAL;
2384 goto out_key_put;
2385 }
2386
2387 len = delim - payload;
2388 if (len > MAX_USERNAME_SIZE || len <= 0) {
000f9bb8 2389 cFYI(1, "Bad value from username search (len=%zd)", len);
8a8798a5
JL		 2390 rc = -EINVAL;
2391 goto out_key_put;
2392 }
2393
2394 vol->username = kstrndup(payload, len, GFP_KERNEL);
2395 if (!vol->username) {
000f9bb8 2396 cFYI(1, "Unable to allocate %zd bytes for username", len);
8a8798a5
JL		 2397 rc = -ENOMEM;
2398 goto out_key_put;
2399 }
2400 cFYI(1, "%s: username=%s", __func__, vol->username);
2401
2402 len = key->datalen - (len + 1);
2403 if (len > MAX_PASSWORD_SIZE || len <= 0) {
000f9bb8 2404 cFYI(1, "Bad len for password search (len=%zd)", len);
8a8798a5
JL		 2405 rc = -EINVAL;
2406 kfree(vol->username);
2407 vol->username = NULL;
2408 goto out_key_put;
2409 }
2410
2411 ++delim;
2412 vol->password = kstrndup(delim, len, GFP_KERNEL);
2413 if (!vol->password) {
000f9bb8 2414 cFYI(1, "Unable to allocate %zd bytes for password", len);
8a8798a5
JL		 2415 rc = -ENOMEM;
2416 kfree(vol->username);
2417 vol->username = NULL;
2418 goto out_key_put;
2419 }
2420
2421out_key_put:
2422 up_read(&key->sem);
2423 key_put(key);
2424out_err:
2425 kfree(desc);
2426 cFYI(1, "%s: returning %d", __func__, rc);
2427 return rc;
2428}
2429#else /* ! CONFIG_KEYS */
2430static inline int
2431cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2432 struct cifs_ses *ses __attribute__((unused)))
2433{
2434 return -ENOSYS;
2435}
2436#endif /* CONFIG_KEYS */
2437
96daf2b0 2438static struct cifs_ses *
36988c76
JL		 2439cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2440{
286170aa
PS		 2441 int rc = -ENOMEM;
2442 unsigned int xid;
96daf2b0 2443 struct cifs_ses *ses;
a9f1b85e
PS		 2444 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2445 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
36988c76 2446
6d5786a3 2447 xid = get_xid();
36988c76 2448
4ff67b72 2449 ses = cifs_find_smb_ses(server, volume_info);
36988c76
JL		 2450 if (ses) {
2451 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2452
36988c76 2453 mutex_lock(&ses->session_mutex);
198b5682
JL		 2454 rc = cifs_negotiate_protocol(xid, ses);
2455 if (rc) {
2456 mutex_unlock(&ses->session_mutex);
2457 /* problem -- put our ses reference */
2458 cifs_put_smb_ses(ses);
6d5786a3 2459 free_xid(xid);
198b5682
JL		 2460 return ERR_PTR(rc);
2461 }
36988c76
JL		 2462 if (ses->need_reconnect) {
2463 cFYI(1, "Session needs reconnect");
2464 rc = cifs_setup_session(xid, ses,
2465 volume_info->local_nls);
2466 if (rc) {
2467 mutex_unlock(&ses->session_mutex);
2468 /* problem -- put our reference */
2469 cifs_put_smb_ses(ses);
6d5786a3 2470 free_xid(xid);
36988c76
JL		 2471 return ERR_PTR(rc);
2472 }
2473 }
2474 mutex_unlock(&ses->session_mutex);
460cf341
JL		 2475
2476 /* existing SMB ses has a server reference already */
2477 cifs_put_tcp_session(server);
6d5786a3 2478 free_xid(xid);
36988c76
JL		 2479 return ses;
2480 }
2481
2482 cFYI(1, "Existing smb sess not found");
2483 ses = sesInfoAlloc();
2484 if (ses == NULL)
2485 goto get_ses_fail;
2486
2487 /* new SMB session uses our server ref */
2488 ses->server = server;
a9f1b85e
PS		 2489 if (server->dstaddr.ss_family == AF_INET6)
2490 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
36988c76 2491 else
a9f1b85e 2492 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
36988c76 2493
8727c8a8
SF		 2494 if (volume_info->username) {
2495 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2496 if (!ses->user_name)
2497 goto get_ses_fail;
2498 }
36988c76
JL		 2499
2500 /* volume_info->password freed at unmount */
2501 if (volume_info->password) {
2502 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2503 if (!ses->password)
2504 goto get_ses_fail;
2505 }
2506 if (volume_info->domainname) {
d3686d54
SP		 2507 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2508 if (!ses->domainName)
2509 goto get_ses_fail;
36988c76 2510 }
3e4b3e1f 2511 ses->cred_uid = volume_info->cred_uid;
36988c76 2512 ses->linux_uid = volume_info->linux_uid;
d9b94201 2513
36988c76
JL		 2514 ses->overrideSecFlg = volume_info->secFlg;
2515
2516 mutex_lock(&ses->session_mutex);
198b5682
JL		 2517 rc = cifs_negotiate_protocol(xid, ses);
2518 if (!rc)
2519 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
36988c76 2520 mutex_unlock(&ses->session_mutex);
c8e56f1f 2521 if (rc)
36988c76
JL		 2522 goto get_ses_fail;
2523
2524 /* success, put it on the list */
3f9bcca7 2525 spin_lock(&cifs_tcp_ses_lock);
36988c76 2526 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3f9bcca7 2527 spin_unlock(&cifs_tcp_ses_lock);
36988c76 2528
6d5786a3 2529 free_xid(xid);
36988c76
JL		 2530 return ses;
2531
2532get_ses_fail:
2533 sesInfoFree(ses);
6d5786a3 2534 free_xid(xid);
36988c76
JL		 2535 return ERR_PTR(rc);
2536}
2537
96daf2b0 2538static int match_tcon(struct cifs_tcon *tcon, const char *unc)
37bb04e5
PS		 2539{
2540 if (tcon->tidStatus == CifsExiting)
2541 return 0;
2542 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2543 return 0;
2544 return 1;
2545}
2546
96daf2b0
SF		 2547static struct cifs_tcon *
2548cifs_find_tcon(struct cifs_ses *ses, const char *unc)
f1987b44
JL		 2549{
2550 struct list_head *tmp;
96daf2b0 2551 struct cifs_tcon *tcon;
f1987b44 2552
3f9bcca7 2553 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2554 list_for_each(tmp, &ses->tcon_list) {
96daf2b0 2555 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
37bb04e5 2556 if (!match_tcon(tcon, unc))
f1987b44 2557 continue;
f1987b44 2558 ++tcon->tc_count;
3f9bcca7 2559 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2560 return tcon;
1da177e4 2561 }
3f9bcca7 2562 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2563 return NULL;
2564}
2565
f1987b44 2566static void
96daf2b0 2567cifs_put_tcon(struct cifs_tcon *tcon)
f1987b44 2568{
2e6e02ab 2569 unsigned int xid;
96daf2b0 2570 struct cifs_ses *ses = tcon->ses;
f1987b44 2571
ac3aa2f8 2572 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
3f9bcca7 2573 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2574 if (--tcon->tc_count > 0) {
3f9bcca7 2575 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2576 return;
2577 }
2578
2579 list_del_init(&tcon->tcon_list);
3f9bcca7 2580 spin_unlock(&cifs_tcp_ses_lock);
f1987b44 2581
6d5786a3 2582 xid = get_xid();
2e6e02ab
PS		 2583 if (ses->server->ops->tree_disconnect)
2584 ses->server->ops->tree_disconnect(xid, tcon);
6d5786a3 2585 _free_xid(xid);
f1987b44 2586
d03382ce 2587 cifs_fscache_release_super_cookie(tcon);
9f841593 2588 tconInfoFree(tcon);
f1987b44
JL		 2589 cifs_put_smb_ses(ses);
2590}
2591
96daf2b0
SF		 2592static struct cifs_tcon *
2593cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
d00c28de
JL		 2594{
2595 int rc, xid;
96daf2b0 2596 struct cifs_tcon *tcon;
d00c28de
JL		 2597
2598 tcon = cifs_find_tcon(ses, volume_info->UNC);
2599 if (tcon) {
2600 cFYI(1, "Found match on UNC path");
2601 /* existing tcon already has a reference */
2602 cifs_put_smb_ses(ses);
2603 if (tcon->seal != volume_info->seal)
2604 cERROR(1, "transport encryption setting "
2605 "conflicts with existing tid");
2606 return tcon;
2607 }
2608
2e6e02ab
PS		 2609 if (!ses->server->ops->tree_connect) {
2610 rc = -ENOSYS;
2611 goto out_fail;
2612 }
2613
d00c28de
JL		 2614 tcon = tconInfoAlloc();
2615 if (tcon == NULL) {
2616 rc = -ENOMEM;
2617 goto out_fail;
2618 }
2619
2620 tcon->ses = ses;
2621 if (volume_info->password) {
2622 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2623 if (!tcon->password) {
2624 rc = -ENOMEM;
2625 goto out_fail;
2626 }
2627 }
2628
2e6e02ab
PS		 2629 /*
2630 * BB Do we need to wrap session_mutex around this TCon call and Unix
2631 * SetFS as we do on SessSetup and reconnect?
2632 */
6d5786a3 2633 xid = get_xid();
2e6e02ab
PS		 2634 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2635 volume_info->local_nls);
6d5786a3 2636 free_xid(xid);
2e6e02ab 2637 cFYI(1, "Tcon rc = %d", rc);
d00c28de
JL		 2638 if (rc)
2639 goto out_fail;
2640
2641 if (volume_info->nodfs) {
2642 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2643 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2644 }
2645 tcon->seal = volume_info->seal;
2e6e02ab
PS		 2646 /*
2647 * We can have only one retry value for a connection to a share so for
2648 * resources mounted more than once to the same server share the last
2649 * value passed in for the retry flag is used.
2650 */
d00c28de
JL		 2651 tcon->retry = volume_info->retry;
2652 tcon->nocase = volume_info->nocase;
2653 tcon->local_lease = volume_info->local_lease;
233839b1 2654 INIT_LIST_HEAD(&tcon->pending_opens);
d00c28de 2655
3f9bcca7 2656 spin_lock(&cifs_tcp_ses_lock);
d00c28de 2657 list_add(&tcon->tcon_list, &ses->tcon_list);
3f9bcca7 2658 spin_unlock(&cifs_tcp_ses_lock);
d00c28de 2659
d03382ce
SJ		 2660 cifs_fscache_get_super_cookie(tcon);
2661
d00c28de
JL		 2662 return tcon;
2663
2664out_fail:
2665 tconInfoFree(tcon);
2666 return ERR_PTR(rc);
2667}
2668
9d002df4
JL		 2669void
2670cifs_put_tlink(struct tcon_link *tlink)
2671{
2672 if (!tlink || IS_ERR(tlink))
2673 return;
2674
2675 if (!atomic_dec_and_test(&tlink->tl_count) ||
2676 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2677 tlink->tl_time = jiffies;
2678 return;
2679 }
2680
2681 if (!IS_ERR(tlink_tcon(tlink)))
2682 cifs_put_tcon(tlink_tcon(tlink));
2683 kfree(tlink);
2684 return;
2685}
d00c28de 2686
25c7f41e 2687static inline struct tcon_link *
cd51875d
PS		 2688cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2689{
2690 return cifs_sb->master_tlink;
2691}
25c7f41e
PS		 2692
2693static int
2694compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2695{
2696 struct cifs_sb_info *old = CIFS_SB(sb);
2697 struct cifs_sb_info *new = mnt_data->cifs_sb;
2698
2699 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2700 return 0;
2701
2702 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2703 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2704 return 0;
2705
25c7f41e 2706 /*
5eba8ab3
JL		 2707 * We want to share sb only if we don't specify an r/wsize or
2708 * specified r/wsize is greater than or equal to existing one.
25c7f41e
PS		 2709 */
2710 if (new->wsize && new->wsize < old->wsize)
2711 return 0;
2712
5eba8ab3
JL		 2713 if (new->rsize && new->rsize < old->rsize)
2714 return 0;
2715
25c7f41e
PS		 2716 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2717 return 0;
2718
2719 if (old->mnt_file_mode != new->mnt_file_mode ||
2720 old->mnt_dir_mode != new->mnt_dir_mode)
2721 return 0;
2722
2723 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2724 return 0;
2725
2726 if (old->actimeo != new->actimeo)
2727 return 0;
2728
2729 return 1;
2730}
2731
2732int
2733cifs_match_super(struct super_block *sb, void *data)
2734{
2735 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2736 struct smb_vol *volume_info;
2737 struct cifs_sb_info *cifs_sb;
2738 struct TCP_Server_Info *tcp_srv;
96daf2b0
SF		 2739 struct cifs_ses *ses;
2740 struct cifs_tcon *tcon;
25c7f41e 2741 struct tcon_link *tlink;
25c7f41e
PS		 2742 int rc = 0;
2743
25c7f41e
PS		 2744 spin_lock(&cifs_tcp_ses_lock);
2745 cifs_sb = CIFS_SB(sb);
2746 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2747 if (IS_ERR(tlink)) {
2748 spin_unlock(&cifs_tcp_ses_lock);
2749 return rc;
2750 }
2751 tcon = tlink_tcon(tlink);
2752 ses = tcon->ses;
2753 tcp_srv = ses->server;
2754
2755 volume_info = mnt_data->vol;
2756
9fa114f7 2757 if (!match_server(tcp_srv, volume_info) ||
25c7f41e
PS		 2758 !match_session(ses, volume_info) ||
2759 !match_tcon(tcon, volume_info->UNC)) {
2760 rc = 0;
2761 goto out;
2762 }
2763
2764 rc = compare_mount_options(sb, mnt_data);
2765out:
25c7f41e 2766 spin_unlock(&cifs_tcp_ses_lock);
f484b5d0 2767 cifs_put_tlink(tlink);
25c7f41e
PS		 2768 return rc;
2769}
2770
1da177e4 2771int
b669f33c 2772get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2e6e02ab
PS		 2773 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2774 struct dfs_info3_param **referrals, int remap)
1da177e4
LT		 2775{
2776 char *temp_unc;
2777 int rc = 0;
2778
b669f33c 2779 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2e6e02ab
PS		 2780 return -ENOSYS;
2781
2782 *num_referrals = 0;
2783 *referrals = NULL;
1da177e4 2784
2e6e02ab 2785 if (ses->ipc_tid == 0) {
1da177e4 2786 temp_unc = kmalloc(2 /* for slashes */ +
2e6e02ab
PS		 2787 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2788 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
1da177e4
LT		 2789 if (temp_unc == NULL)
2790 return -ENOMEM;
2791 temp_unc[0] = '\\';
2792 temp_unc[1] = '\\';
2e6e02ab
PS		 2793 strcpy(temp_unc + 2, ses->serverName);
2794 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2795 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2796 nls_codepage);
2797 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
1da177e4
LT		 2798 kfree(temp_unc);
2799 }
2800 if (rc == 0)
b669f33c
PS		 2801 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2802 referrals, num_referrals,
2803 nls_codepage, remap);
2e6e02ab
PS		 2804 /*
2805 * BB - map targetUNCs to dfs_info3 structures, here or in
b669f33c 2806 * ses->server->ops->get_dfs_refer.
2e6e02ab 2807 */
1da177e4
LT		 2808
2809 return rc;
2810}
2811
09e50d55
JL		 2812#ifdef CONFIG_DEBUG_LOCK_ALLOC
2813static struct lock_class_key cifs_key[2];
2814static struct lock_class_key cifs_slock_key[2];
2815
2816static inline void
2817cifs_reclassify_socket4(struct socket *sock)
2818{
2819 struct sock *sk = sock->sk;
2820 BUG_ON(sock_owned_by_user(sk));
2821 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2822 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2823}
2824
2825static inline void
2826cifs_reclassify_socket6(struct socket *sock)
2827{
2828 struct sock *sk = sock->sk;
2829 BUG_ON(sock_owned_by_user(sk));
2830 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2831 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2832}
2833#else
2834static inline void
2835cifs_reclassify_socket4(struct socket *sock)
2836{
2837}
2838
2839static inline void
2840cifs_reclassify_socket6(struct socket *sock)
2841{
2842}
2843#endif
2844
1da177e4 2845/* See RFC1001 section 14 on representation of Netbios names */
50c2f753 2846static void rfc1002mangle(char *target, char *source, unsigned int length)
1da177e4 2847{
50c2f753 2848 unsigned int i, j;
1da177e4 2849
50c2f753 2850 for (i = 0, j = 0; i < (length); i++) {
1da177e4
LT		 2851 /* mask a nibble at a time and encode */
2852 target[j] = 'A' + (0x0F & (source[i] >> 4));
2853 target[j+1] = 'A' + (0x0F & source[i]);
50c2f753 2854 j += 2;
1da177e4
LT		 2855 }
2856
2857}
2858
3eb9a889
BG		 2859static int
2860bind_socket(struct TCP_Server_Info *server)
2861{
2862 int rc = 0;
2863 if (server->srcaddr.ss_family != AF_UNSPEC) {
2864 /* Bind to the specified local IP address */
2865 struct socket *socket = server->ssocket;
2866 rc = socket->ops->bind(socket,
2867 (struct sockaddr *) &server->srcaddr,
2868 sizeof(server->srcaddr));
2869 if (rc < 0) {
2870 struct sockaddr_in *saddr4;
2871 struct sockaddr_in6 *saddr6;
2872 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2873 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2874 if (saddr6->sin6_family == AF_INET6)
2875 cERROR(1, "cifs: "
ac3aa2f8 2876 "Failed to bind to: %pI6c, error: %d",
3eb9a889
BG		 2877 &saddr6->sin6_addr, rc);
2878 else
2879 cERROR(1, "cifs: "
ac3aa2f8 2880 "Failed to bind to: %pI4, error: %d",
3eb9a889
BG		 2881 &saddr4->sin_addr.s_addr, rc);
2882 }
2883 }
2884 return rc;
2885}
1da177e4
LT		 2886
2887static int
a9f1b85e 2888ip_rfc1001_connect(struct TCP_Server_Info *server)
1da177e4
LT		 2889{
2890 int rc = 0;
a9f1b85e
PS		 2891 /*
2892 * some servers require RFC1001 sessinit before sending
2893 * negprot - BB check reconnection in case where second
2894 * sessinit is sent but no second negprot
2895 */
2896 struct rfc1002_session_packet *ses_init_buf;
2897 struct smb_hdr *smb_buf;
2898 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2899 GFP_KERNEL);
2900 if (ses_init_buf) {
2901 ses_init_buf->trailer.session_req.called_len = 32;
2902
2903 if (server->server_RFC1001_name &&
2904 server->server_RFC1001_name[0] != 0)
2905 rfc1002mangle(ses_init_buf->trailer.
2906 session_req.called_name,
2907 server->server_RFC1001_name,
2908 RFC1001_NAME_LEN_WITH_NULL);
2909 else
2910 rfc1002mangle(ses_init_buf->trailer.
2911 session_req.called_name,
2912 DEFAULT_CIFS_CALLED_NAME,
2913 RFC1001_NAME_LEN_WITH_NULL);
2914
2915 ses_init_buf->trailer.session_req.calling_len = 32;
2916
2917 /*
2918 * calling name ends in null (byte 16) from old smb
2919 * convention.
2920 */
2921 if (server->workstation_RFC1001_name &&
2922 server->workstation_RFC1001_name[0] != 0)
2923 rfc1002mangle(ses_init_buf->trailer.
2924 session_req.calling_name,
2925 server->workstation_RFC1001_name,
2926 RFC1001_NAME_LEN_WITH_NULL);
2927 else
2928 rfc1002mangle(ses_init_buf->trailer.
2929 session_req.calling_name,
2930 "LINUX_CIFS_CLNT",
2931 RFC1001_NAME_LEN_WITH_NULL);
2932
2933 ses_init_buf->trailer.session_req.scope1 = 0;
2934 ses_init_buf->trailer.session_req.scope2 = 0;
2935 smb_buf = (struct smb_hdr *)ses_init_buf;
2936
2937 /* sizeof RFC1002_SESSION_REQUEST with no scope */
be8e3b00 2938 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
a9f1b85e
PS		 2939 rc = smb_send(server, smb_buf, 0x44);
2940 kfree(ses_init_buf);
2941 /*
2942 * RFC1001 layer in at least one server
2943 * requires very short break before negprot
2944 * presumably because not expecting negprot
2945 * to follow so fast. This is a simple
2946 * solution that works without
2947 * complicating the code and causes no
2948 * significant slowing down on mount
2949 * for everyone else
2950 */
2951 usleep_range(1000, 2000);
2952 }
2953 /*
2954 * else the negprot may still work without this
2955 * even though malloc failed
2956 */
2957
2958 return rc;
2959}
2960
2961static int
2962generic_ip_connect(struct TCP_Server_Info *server)
2963{
2964 int rc = 0;
6da97910 2965 __be16 sport;
a9f1b85e 2966 int slen, sfamily;
bcf4b106 2967 struct socket *socket = server->ssocket;
a9f1b85e
PS		 2968 struct sockaddr *saddr;
2969
2970 saddr = (struct sockaddr *) &server->dstaddr;
2971
2972 if (server->dstaddr.ss_family == AF_INET6) {
2973 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2974 slen = sizeof(struct sockaddr_in6);
2975 sfamily = AF_INET6;
2976 } else {
2977 sport = ((struct sockaddr_in *) saddr)->sin_port;
2978 slen = sizeof(struct sockaddr_in);
2979 sfamily = AF_INET;
2980 }
1da177e4 2981
bcf4b106 2982 if (socket == NULL) {
f1d0c998
RL		 2983 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2984 IPPROTO_TCP, &socket, 1);
1da177e4 2985 if (rc < 0) {
b6b38f70 2986 cERROR(1, "Error %d creating socket", rc);
a9f1b85e 2987 server->ssocket = NULL;
1da177e4 2988 return rc;
1da177e4 2989 }
bcf4b106
JL		 2990
2991 /* BB other socket options to set KEEPALIVE, NODELAY? */
b6b38f70 2992 cFYI(1, "Socket created");
bcf4b106
JL		 2993 server->ssocket = socket;
2994 socket->sk->sk_allocation = GFP_NOFS;
a9f1b85e
PS		 2995 if (sfamily == AF_INET6)
2996 cifs_reclassify_socket6(socket);
2997 else
2998 cifs_reclassify_socket4(socket);
1da177e4
LT		 2999 }
3000
3eb9a889
BG		 3001 rc = bind_socket(server);
3002 if (rc < 0)
3003 return rc;
3004
bcf4b106
JL		 3005 /*
3006 * Eventually check for other socket options to change from
a9f1b85e
PS		 3007 * the default. sock_setsockopt not used because it expects
3008 * user space buffer
bcf4b106
JL		 3009 */
3010 socket->sk->sk_rcvtimeo = 7 * HZ;
da505c38 3011 socket->sk->sk_sndtimeo = 5 * HZ;
edf1ae40 3012
b387eaeb 3013 /* make the bufsizes depend on wsize/rsize and max requests */
bcf4b106
JL		 3014 if (server->noautotune) {
3015 if (socket->sk->sk_sndbuf < (200 * 1024))
3016 socket->sk->sk_sndbuf = 200 * 1024;
3017 if (socket->sk->sk_rcvbuf < (140 * 1024))
3018 socket->sk->sk_rcvbuf = 140 * 1024;
edf1ae40 3019 }
1da177e4 3020
6a5fa236 3021 if (server->tcp_nodelay) {
a9f1b85e 3022 int val = 1;
6a5fa236
SF		 3023 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3024 (char *)&val, sizeof(val));
3025 if (rc)
b6b38f70 3026 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
6a5fa236
SF		 3027 }
3028
b6b38f70 3029 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
bcf4b106 3030 socket->sk->sk_sndbuf,
b6b38f70 3031 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
bcf4b106 3032
ee1b3ea9
JL		 3033 rc = socket->ops->connect(socket, saddr, slen, 0);
3034 if (rc < 0) {
3035 cFYI(1, "Error %d connecting to server", rc);
3036 sock_release(socket);
3037 server->ssocket = NULL;
3038 return rc;
3039 }
3040
a9f1b85e
PS		 3041 if (sport == htons(RFC1001_PORT))
3042 rc = ip_rfc1001_connect(server);
50c2f753 3043
1da177e4
LT		 3044 return rc;
3045}
3046
3047static int
a9f1b85e 3048ip_connect(struct TCP_Server_Info *server)
1da177e4 3049{
6da97910 3050 __be16 *sport;
a9f1b85e
PS		 3051 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3052 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1da177e4 3053
a9f1b85e
PS		 3054 if (server->dstaddr.ss_family == AF_INET6)
3055 sport = &addr6->sin6_port;
3056 else
3057 sport = &addr->sin_port;
1da177e4 3058
a9f1b85e
PS		 3059 if (*sport == 0) {
3060 int rc;
1da177e4 3061
a9f1b85e
PS		 3062 /* try with 445 port at first */
3063 *sport = htons(CIFS_PORT);
3eb9a889 3064
a9f1b85e 3065 rc = generic_ip_connect(server);
1da177e4 3066 if (rc >= 0)
a9f1b85e 3067 return rc;
6a5fa236 3068
a9f1b85e
PS		 3069 /* if it failed, try with 139 port */
3070 *sport = htons(RFC1001_PORT);
6a5fa236
SF		 3071 }
3072
a9f1b85e 3073 return generic_ip_connect(server);
1da177e4
LT		 3074}
3075
6d5786a3 3076void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2c6292ae 3077 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
8af18971
SF		 3078{
3079 /* if we are reconnecting then should we check to see if
3080 * any requested capabilities changed locally e.g. via
3081 * remount but we can not do much about it here
3082 * if they have (even if we could detect it by the following)
3083 * Perhaps we could add a backpointer to array of sb from tcon
3084 * or if we change to make all sb to same share the same
3085 * sb as NFS - then we only have one backpointer to sb.
3086 * What if we wanted to mount the server share twice once with
3087 * and once without posixacls or posix paths? */
3088 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
50c2f753 3089
c18c842b
SF		 3090 if (vol_info && vol_info->no_linux_ext) {
3091 tcon->fsUnixInfo.Capability = 0;
3092 tcon->unix_ext = 0; /* Unix Extensions disabled */
b6b38f70 3093 cFYI(1, "Linux protocol extensions disabled");
c18c842b
SF		 3094 return;
3095 } else if (vol_info)
3096 tcon->unix_ext = 1; /* Unix Extensions supported */
3097
3098 if (tcon->unix_ext == 0) {
b6b38f70 3099 cFYI(1, "Unix extensions disabled so not set on reconnect");
c18c842b
SF		 3100 return;
3101 }
50c2f753 3102
fb8c4b14 3103 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
8af18971 3104 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
6848b733 3105 cFYI(1, "unix caps which server supports %lld", cap);
8af18971
SF		 3106 /* check for reconnect case in which we do not
3107 want to change the mount behavior if we can avoid it */
fb8c4b14 3108 if (vol_info == NULL) {
50c2f753 3109 /* turn off POSIX ACL and PATHNAMES if not set
8af18971
SF		 3110 originally at mount time */
3111 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3112 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
11b6d645
IM		 3113 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3114 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
b6b38f70 3115 cERROR(1, "POSIXPATH support change");
8af18971 3116 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
11b6d645 3117 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
b6b38f70
JP		 3118 cERROR(1, "possible reconnect error");
3119 cERROR(1, "server disabled POSIX path support");
11b6d645 3120 }
8af18971 3121 }
50c2f753 3122
6848b733
SF		 3123 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3124 cERROR(1, "per-share encryption not supported yet");
3125
8af18971 3126 cap &= CIFS_UNIX_CAP_MASK;
75865f8c 3127 if (vol_info && vol_info->no_psx_acl)
8af18971 3128 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
75865f8c 3129 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
b6b38f70 3130 cFYI(1, "negotiated posix acl support");
2c6292ae
AV		 3131 if (cifs_sb)
3132 cifs_sb->mnt_cifs_flags |=
3133 CIFS_MOUNT_POSIXACL;
8af18971
SF		 3134 }
3135
75865f8c 3136 if (vol_info && vol_info->posix_paths == 0)
8af18971 3137 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
75865f8c 3138 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
b6b38f70 3139 cFYI(1, "negotiate posix pathnames");
2c6292ae
AV		 3140 if (cifs_sb)
3141 cifs_sb->mnt_cifs_flags |=
8af18971
SF		 3142 CIFS_MOUNT_POSIX_PATHS;
3143 }
50c2f753 3144
b6b38f70 3145 cFYI(1, "Negotiate caps 0x%x", (int)cap);
8af18971 3146#ifdef CONFIG_CIFS_DEBUG2
75865f8c 3147 if (cap & CIFS_UNIX_FCNTL_CAP)
b6b38f70 3148 cFYI(1, "FCNTL cap");
75865f8c 3149 if (cap & CIFS_UNIX_EXTATTR_CAP)
b6b38f70 3150 cFYI(1, "EXTATTR cap");
75865f8c 3151 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
b6b38f70 3152 cFYI(1, "POSIX path cap");
75865f8c 3153 if (cap & CIFS_UNIX_XATTR_CAP)
b6b38f70 3154 cFYI(1, "XATTR cap");
75865f8c 3155 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
b6b38f70 3156 cFYI(1, "POSIX ACL cap");
75865f8c 3157 if (cap & CIFS_UNIX_LARGE_READ_CAP)
b6b38f70 3158 cFYI(1, "very large read cap");
75865f8c 3159 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
b6b38f70 3160 cFYI(1, "very large write cap");
6848b733
SF		 3161 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3162 cFYI(1, "transport encryption cap");
3163 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3164 cFYI(1, "mandatory transport encryption cap");
8af18971
SF		 3165#endif /* CIFS_DEBUG2 */
3166 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
442aa310 3167 if (vol_info == NULL) {
b6b38f70 3168 cFYI(1, "resetting capabilities failed");
442aa310 3169 } else
b6b38f70 3170 cERROR(1, "Negotiating Unix capabilities "
ac3aa2f8
JL		 3171 "with the server failed. Consider "
3172 "mounting with the Unix Extensions "
3173 "disabled if problems are found "
5a44b319 3174 "by specifying the nounix mount "
b6b38f70 3175 "option.");
5a44b319 3176
8af18971
SF		 3177 }
3178 }
3179}
3180
724d9f1c
PS		 3181void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3182 struct cifs_sb_info *cifs_sb)
b1c8d2b4 3183{
2de970ff
JL		 3184 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3185
2ced6f69
AV		 3186 spin_lock_init(&cifs_sb->tlink_tree_lock);
3187 cifs_sb->tlink_tree = RB_ROOT;
3188
25c7f41e 3189 /*
5eba8ab3
JL		 3190 * Temporarily set r/wsize for matching superblock. If we end up using
3191 * new sb then client will later negotiate it downward if needed.
25c7f41e 3192 */
5eba8ab3 3193 cifs_sb->rsize = pvolume_info->rsize;
25c7f41e
PS		 3194 cifs_sb->wsize = pvolume_info->wsize;
3195
3b795210
SF		 3196 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3197 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3198 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3199 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
5206efd6 3200 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
b6b38f70 3201 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3b795210 3202
6d20e840 3203 cifs_sb->actimeo = pvolume_info->actimeo;
724d9f1c 3204 cifs_sb->local_nls = pvolume_info->local_nls;
6d20e840 3205
3b795210
SF		 3206 if (pvolume_info->noperm)
3207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3208 if (pvolume_info->setuids)
3209 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3210 if (pvolume_info->server_ino)
3211 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3212 if (pvolume_info->remap)
3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3214 if (pvolume_info->no_xattr)
3215 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3216 if (pvolume_info->sfu_emul)
3217 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3218 if (pvolume_info->nobrl)
3219 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
be652445 3220 if (pvolume_info->nostrictsync)
4717bed6 3221 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
13a6e42a
SF		 3222 if (pvolume_info->mand_lock)
3223 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
d4ffff1f
PS		 3224 if (pvolume_info->rwpidforward)
3225 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3b795210
SF		 3226 if (pvolume_info->cifs_acl)
3227 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3c7c87fd 3228 if (pvolume_info->backupuid_specified) {
3d3ea8e6 3229 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3c7c87fd
SP		 3230 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3231 }
3232 if (pvolume_info->backupgid_specified) {
3d3ea8e6 3233 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3c7c87fd
SP		 3234 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3235 }
3b795210
SF		 3236 if (pvolume_info->override_uid)
3237 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3238 if (pvolume_info->override_gid)
3239 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3240 if (pvolume_info->dynperm)
3241 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
fa1df75d
SJ		 3242 if (pvolume_info->fsc)
3243 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
0eb8a132
JL		 3244 if (pvolume_info->multiuser)
3245 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3246 CIFS_MOUNT_NO_PERM);
d39454ff
PS		 3247 if (pvolume_info->strict_io)
3248 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3b795210 3249 if (pvolume_info->direct_io) {
b6b38f70 3250 cFYI(1, "mounting share using direct i/o");
3b795210
SF		 3251 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3252 }
736a3320
SM		 3253 if (pvolume_info->mfsymlinks) {
3254 if (pvolume_info->sfu_emul) {
3255 cERROR(1, "mount option mfsymlinks ignored if sfu "
3256 "mount option is used");
3257 } else {
3258 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3259 }
3260 }
3b795210
SF		 3261
3262 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
b6b38f70
JP		 3263 cERROR(1, "mount option dynperm ignored if cifsacl "
3264 "mount option supported");
b1c8d2b4
JL		 3265}
3266
b9bce2e9
JL		 3267static void
3268cleanup_volume_info_contents(struct smb_vol *volume_info)
1bfe73c2 3269{
b946845a 3270 kfree(volume_info->username);
1bfe73c2 3271 kzfree(volume_info->password);
95c75454 3272 kfree(volume_info->UNC);
b946845a
SF		 3273 kfree(volume_info->domainname);
3274 kfree(volume_info->iocharset);
1bfe73c2 3275 kfree(volume_info->prepath);
b9bce2e9
JL		 3276}
3277
3278void
3279cifs_cleanup_volume_info(struct smb_vol *volume_info)
3280{
3281 if (!volume_info)
3282 return;
3283 cleanup_volume_info_contents(volume_info);
1bfe73c2 3284 kfree(volume_info);
1bfe73c2
IM		 3285}
3286
b9bce2e9 3287
2d6d589d 3288#ifdef CONFIG_CIFS_DFS_UPCALL
6d3ea7e4
SF		 3289/*
3290 * cifs_build_path_to_root returns full path to root when we do not have an
3291 * exiting connection (tcon)
3292 */
1bfe73c2 3293static char *
b2a0fa15 3294build_unc_path_to_root(const struct smb_vol *vol,
1bfe73c2
IM		 3295 const struct cifs_sb_info *cifs_sb)
3296{
b2a0fa15 3297 char *full_path, *pos;
839db3d1 3298 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
b2a0fa15 3299 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
1bfe73c2 3300
b2a0fa15 3301 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
1bfe73c2
IM		 3302 if (full_path == NULL)
3303 return ERR_PTR(-ENOMEM);
3304
b2a0fa15
JL		 3305 strncpy(full_path, vol->UNC, unc_len);
3306 pos = full_path + unc_len;
3307
3308 if (pplen) {
839db3d1 3309 *pos++ = CIFS_DIR_SEP(cifs_sb);
b2a0fa15
JL		 3310 strncpy(pos, vol->prepath, pplen);
3311 pos += pplen;
3312 }
3313
3314 *pos = '\0'; /* add trailing null */
f87d39d9 3315 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
b2a0fa15 3316 cFYI(1, "%s: full_path=%s", __func__, full_path);
1bfe73c2
IM		 3317 return full_path;
3318}
dd613945
SF		 3319
3320/*
3321 * Perform a dfs referral query for a share and (optionally) prefix
3322 *
046462ab
SF		 3323 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3324 * to a string containing updated options for the submount. Otherwise it
3325 * will be left untouched.
dd613945
SF		 3326 *
3327 * Returns the rc from get_dfs_path to the caller, which can be used to
3328 * determine whether there were referrals.
3329 */
3330static int
b669f33c 3331expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
dd613945 3332 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
046462ab 3333 int check_prefix)
dd613945
SF		 3334{
3335 int rc;
3336 unsigned int num_referrals = 0;
3337 struct dfs_info3_param *referrals = NULL;
3338 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3339
3340 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3341 if (IS_ERR(full_path))
3342 return PTR_ERR(full_path);
3343
3344 /* For DFS paths, skip the first '\' of the UNC */
3345 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3346
b669f33c 3347 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
dd613945
SF		 3348 &num_referrals, &referrals,
3349 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3350
3351 if (!rc && num_referrals > 0) {
3352 char *fake_devname = NULL;
3353
3354 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3355 full_path + 1, referrals,
3356 &fake_devname);
3357
3358 free_dfs_info_array(referrals, num_referrals);
046462ab 3359
dd613945
SF		 3360 if (IS_ERR(mdata)) {
3361 rc = PTR_ERR(mdata);
3362 mdata = NULL;
b9bce2e9
JL		 3363 } else {
3364 cleanup_volume_info_contents(volume_info);
b9bce2e9
JL		 3365 rc = cifs_setup_volume_info(volume_info, mdata,
3366 fake_devname);
dd613945 3367 }
b9bce2e9
JL		 3368 kfree(fake_devname);
3369 kfree(cifs_sb->mountdata);
046462ab 3370 cifs_sb->mountdata = mdata;
dd613945
SF		 3371 }
3372 kfree(full_path);
3373 return rc;
3374}
2d6d589d 3375#endif
1bfe73c2 3376
04db79b0
JL		 3377static int
3378cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3379 const char *devname)
1da177e4 3380{
724d9f1c 3381 int rc = 0;
1da177e4 3382
04db79b0
JL		 3383 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3384 return -EINVAL;
1da177e4 3385
7586b765 3386 if (volume_info->nullauth) {
04febabc
JL		 3387 cFYI(1, "Anonymous login");
3388 kfree(volume_info->username);
3389 volume_info->username = NULL;
7586b765 3390 } else if (volume_info->username) {
1da177e4 3391 /* BB fixme parse for domain name here */
b6b38f70 3392 cFYI(1, "Username: %s", volume_info->username);
1da177e4 3393 } else {
bf820679 3394 cifserror("No username specified");
50c2f753
SF		 3395 /* In userspace mount helper we can get user name from alternate
3396 locations such as env variables and files on disk */
04db79b0 3397 return -EINVAL;
1da177e4
LT		 3398 }
3399
1da177e4 3400 /* this is needed for ASCII cp to Unicode converts */
7586b765 3401 if (volume_info->iocharset == NULL) {
a5fc4ce0
JL		 3402 /* load_nls_default cannot return null */
3403 volume_info->local_nls = load_nls_default();
1da177e4 3404 } else {
a5fc4ce0
JL		 3405 volume_info->local_nls = load_nls(volume_info->iocharset);
3406 if (volume_info->local_nls == NULL) {
b6b38f70
JP		 3407 cERROR(1, "CIFS mount error: iocharset %s not found",
3408 volume_info->iocharset);
04db79b0 3409 return -ELIBACC;
1da177e4
LT		 3410 }
3411 }
724d9f1c 3412
724d9f1c
PS		 3413 return rc;
3414}
3415
04db79b0
JL		 3416struct smb_vol *
3417cifs_get_volume_info(char *mount_data, const char *devname)
3418{
3419 int rc;
3420 struct smb_vol *volume_info;
3421
6ee9542a 3422 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
04db79b0
JL		 3423 if (!volume_info)
3424 return ERR_PTR(-ENOMEM);
3425
3426 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3427 if (rc) {
3428 cifs_cleanup_volume_info(volume_info);
3429 volume_info = ERR_PTR(rc);
3430 }
3431
3432 return volume_info;
3433}
3434
724d9f1c 3435int
2c6292ae 3436cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
724d9f1c 3437{
1daaae8f 3438 int rc;
6d5786a3 3439 unsigned int xid;
af4281dc 3440 struct cifs_ses *ses;
96daf2b0 3441 struct cifs_tcon *tcon;
af4281dc 3442 struct TCP_Server_Info *server;
724d9f1c
PS		 3443 char *full_path;
3444 struct tcon_link *tlink;
3445#ifdef CONFIG_CIFS_DFS_UPCALL
3446 int referral_walks_count = 0;
20547490 3447#endif
dd854466
AV		 3448
3449 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3450 if (rc)
3451 return rc;
3452
20547490 3453#ifdef CONFIG_CIFS_DFS_UPCALL
724d9f1c
PS		 3454try_mount_again:
3455 /* cleanup activities if we're chasing a referral */
3456 if (referral_walks_count) {
3457 if (tcon)
3458 cifs_put_tcon(tcon);
af4281dc
PS		 3459 else if (ses)
3460 cifs_put_smb_ses(ses);
724d9f1c 3461
6d5786a3 3462 free_xid(xid);
724d9f1c
PS		 3463 }
3464#endif
1daaae8f 3465 rc = 0;
724d9f1c 3466 tcon = NULL;
af4281dc
PS		 3467 ses = NULL;
3468 server = NULL;
724d9f1c
PS		 3469 full_path = NULL;
3470 tlink = NULL;
3471
6d5786a3 3472 xid = get_xid();
1da177e4 3473
63c038c2 3474 /* get a reference to a tcp session */
af4281dc
PS		 3475 server = cifs_get_tcp_session(volume_info);
3476 if (IS_ERR(server)) {
3477 rc = PTR_ERR(server);
dd854466 3478 bdi_destroy(&cifs_sb->bdi);
63c038c2 3479 goto out;
1da177e4
LT		 3480 }
3481
36988c76 3482 /* get a reference to a SMB session */
af4281dc
PS		 3483 ses = cifs_get_smb_ses(server, volume_info);
3484 if (IS_ERR(ses)) {
3485 rc = PTR_ERR(ses);
3486 ses = NULL;
36988c76 3487 goto mount_fail_check;
1da177e4 3488 }
50c2f753 3489
d00c28de 3490 /* search for existing tcon to this server share */
af4281dc 3491 tcon = cifs_get_tcon(ses, volume_info);
d00c28de
JL		 3492 if (IS_ERR(tcon)) {
3493 rc = PTR_ERR(tcon);
3494 tcon = NULL;
1bfe73c2 3495 goto remote_path_check;
d00c28de 3496 }
1bfe73c2 3497
d82c2df5 3498 /* tell server which Unix caps we support */
29e20f9c 3499 if (cap_unix(tcon->ses)) {
d82c2df5
SF		 3500 /* reset of caps checks mount to see if unix extensions
3501 disabled for just this mount */
2c6292ae 3502 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
6848b733
SF		 3503 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3504 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3505 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3506 rc = -EACCES;
3507 goto mount_fail_check;
3508 }
3509 } else
d82c2df5 3510 tcon->unix_ext = 0; /* server does not support them */
c18c842b 3511
af4281dc
PS		 3512 /* do not care if a following call succeed - informational */
3513 if (!tcon->ipc && server->ops->qfs_tcon)
3514 server->ops->qfs_tcon(xid, tcon);
6848b733 3515
24985c53
PS		 3516 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3517 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
f7910cbd 3518
66bfaadc 3519 /* tune readahead according to rsize */
8f71465c 3520 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
f7910cbd 3521
1bfe73c2 3522remote_path_check:
c1508ca2
SF		 3523#ifdef CONFIG_CIFS_DFS_UPCALL
3524 /*
3525 * Perform an unconditional check for whether there are DFS
3526 * referrals for this path without prefix, to provide support
3527 * for DFS referrals from w2k8 servers which don't seem to respond
3528 * with PATH_NOT_COVERED to requests that include the prefix.
3529 * Chase the referral if found, otherwise continue normally.
3530 */
3531 if (referral_walks_count == 0) {
af4281dc
PS		 3532 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3533 false);
c1508ca2
SF		 3534 if (!refrc) {
3535 referral_walks_count++;
3536 goto try_mount_again;
3537 }
3538 }
3539#endif
3540
f87d39d9 3541 /* check if a whole path is not remote */
70945643 3542 if (!rc && tcon) {
68889f26
PS		 3543 if (!server->ops->is_path_accessible) {
3544 rc = -ENOSYS;
3545 goto mount_fail_check;
3546 }
6d3ea7e4
SF		 3547 /*
3548 * cifs_build_path_to_root works only when we have a valid tcon
3549 */
3550 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
e4cce94c
IM		 3551 if (full_path == NULL) {
3552 rc = -ENOMEM;
3553 goto mount_fail_check;
3554 }
68889f26
PS		 3555 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3556 full_path);
03ceace5 3557 if (rc != 0 && rc != -EREMOTE) {
e4cce94c
IM		 3558 kfree(full_path);
3559 goto mount_fail_check;
3560 }
3561 kfree(full_path);
3562 }
3563
1bfe73c2
IM		 3564 /* get referral if needed */
3565 if (rc == -EREMOTE) {
d036f50f 3566#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8
IM		 3567 if (referral_walks_count > MAX_NESTED_LINKS) {
3568 /*
3569 * BB: when we implement proper loop detection,
3570 * we will remove this check. But now we need it
3571 * to prevent an indefinite loop if 'DFS tree' is
3572 * misconfigured (i.e. has loops).
3573 */
3574 rc = -ELOOP;
3575 goto mount_fail_check;
3576 }
1bfe73c2 3577
af4281dc 3578 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
7b91e266 3579
dd613945 3580 if (!rc) {
5c2503a8 3581 referral_walks_count++;
1bfe73c2
IM		 3582 goto try_mount_again;
3583 }
dd613945 3584 goto mount_fail_check;
d036f50f
SF		 3585#else /* No DFS support, return error on mount */
3586 rc = -EOPNOTSUPP;
3587#endif
1bfe73c2
IM		 3588 }
3589
9d002df4
JL		 3590 if (rc)
3591 goto mount_fail_check;
3592
3593 /* now, hang the tcon off of the superblock */
3594 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3595 if (tlink == NULL) {
3596 rc = -ENOMEM;
3597 goto mount_fail_check;
3598 }
3599
af4281dc 3600 tlink->tl_uid = ses->linux_uid;
9d002df4
JL		 3601 tlink->tl_tcon = tcon;
3602 tlink->tl_time = jiffies;
3603 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3604 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3605
b647c35f 3606 cifs_sb->master_tlink = tlink;
9d002df4 3607 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3608 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
9d002df4 3609 spin_unlock(&cifs_sb->tlink_tree_lock);
413e661c 3610
da472fc8 3611 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 3612 TLINK_IDLE_EXPIRE);
3613
1bfe73c2
IM		 3614mount_fail_check:
3615 /* on error free sesinfo and tcon struct if needed */
3616 if (rc) {
1bfe73c2 3617 /* If find_unc succeeded then rc == 0 so we can not end */
25985edc 3618 /* up accidentally freeing someone elses tcon struct */
1bfe73c2
IM		 3619 if (tcon)
3620 cifs_put_tcon(tcon);
af4281dc
PS		 3621 else if (ses)
3622 cifs_put_smb_ses(ses);
1bfe73c2 3623 else
af4281dc 3624 cifs_put_tcp_session(server);
dd854466 3625 bdi_destroy(&cifs_sb->bdi);
1bfe73c2
IM		 3626 }
3627
70fe7dc0 3628out:
6d5786a3 3629 free_xid(xid);
1da177e4
LT		 3630 return rc;
3631}
3632
8d1bca32
JL		 3633/*
3634 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3635 * pointer may be NULL.
3636 */
1da177e4 3637int
2e6e02ab 3638CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
96daf2b0 3639 const char *tree, struct cifs_tcon *tcon,
1da177e4
LT		 3640 const struct nls_table *nls_codepage)
3641{
3642 struct smb_hdr *smb_buffer;
3643 struct smb_hdr *smb_buffer_response;
3644 TCONX_REQ *pSMB;
3645 TCONX_RSP *pSMBr;
3646 unsigned char *bcc_ptr;
3647 int rc = 0;
690c522f
JL		 3648 int length;
3649 __u16 bytes_left, count;
1da177e4
LT		 3650
3651 if (ses == NULL)
3652 return -EIO;
3653
3654 smb_buffer = cifs_buf_get();
ca43e3be 3655 if (smb_buffer == NULL)
1da177e4 3656 return -ENOMEM;
ca43e3be 3657
1da177e4
LT		 3658 smb_buffer_response = smb_buffer;
3659
3660 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3661 NULL /*no tid */ , 4 /*wct */ );
1982c344 3662
88257360 3663 smb_buffer->Mid = get_next_mid(ses->server);
1da177e4
LT		 3664 smb_buffer->Uid = ses->Suid;
3665 pSMB = (TCONX_REQ *) smb_buffer;
3666 pSMBr = (TCONX_RSP *) smb_buffer_response;
3667
3668 pSMB->AndXCommand = 0xFF;
3669 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
1da177e4 3670 bcc_ptr = &pSMB->Password[0];
8d1bca32 3671 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
eeac8047 3672 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
7c7b25bc 3673 *bcc_ptr = 0; /* password is null byte */
eeac8047 3674 bcc_ptr++; /* skip password */
7c7b25bc 3675 /* already aligned so no need to do it below */
eeac8047 3676 } else {
540b2e37 3677 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
eeac8047
SF		 3678 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3679 specified as required (when that support is added to
3680 the vfs in the future) as only NTLM or the much
7c7b25bc 3681 weaker LANMAN (which we do not send by default) is accepted
eeac8047
SF		 3682 by Samba (not sure whether other servers allow
3683 NTLMv2 password here) */
7c7b25bc 3684#ifdef CONFIG_CIFS_WEAK_PW_HASH
04912d6a 3685 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
00e485b0 3686 (ses->server->secType == LANMAN))
d3ba50b1 3687 calc_lanman_hash(tcon->password, ses->server->cryptkey,
96daf2b0 3688 ses->server->sec_mode &
4e53a3fb
JL		 3689 SECMODE_PW_ENCRYPT ? true : false,
3690 bcc_ptr);
7c7b25bc
SF		 3691 else
3692#endif /* CIFS_WEAK_PW_HASH */
ee2c9258 3693 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
9ef5992e 3694 bcc_ptr, nls_codepage);
eeac8047 3695
540b2e37 3696 bcc_ptr += CIFS_AUTH_RESP_SIZE;
fb8c4b14 3697 if (ses->capabilities & CAP_UNICODE) {
7c7b25bc
SF		 3698 /* must align unicode strings */
3699 *bcc_ptr = 0; /* null byte password */
3700 bcc_ptr++;
3701 }
eeac8047 3702 }
1da177e4 3703
96daf2b0 3704 if (ses->server->sec_mode &
a878fb22 3705 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1da177e4
LT		 3706 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3707
3708 if (ses->capabilities & CAP_STATUS32) {
3709 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3710 }
3711 if (ses->capabilities & CAP_DFS) {
3712 smb_buffer->Flags2 |= SMBFLG2_DFS;
3713 }
3714 if (ses->capabilities & CAP_UNICODE) {
3715 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3716 length =
acbbb76a 3717 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
50c2f753 3718 6 /* max utf8 char length in bytes */ *
a878fb22
SF		 3719 (/* server len*/ + 256 /* share len */), nls_codepage);
3720 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
1da177e4
LT		 3721 bcc_ptr += 2; /* skip trailing null */
3722 } else { /* ASCII */
1da177e4
LT		 3723 strcpy(bcc_ptr, tree);
3724 bcc_ptr += strlen(tree) + 1;
3725 }
3726 strcpy(bcc_ptr, "?????");
3727 bcc_ptr += strlen("?????");
3728 bcc_ptr += 1;
3729 count = bcc_ptr - &pSMB->Password[0];
be8e3b00
SF		 3730 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3731 pSMB->hdr.smb_buf_length) + count);
1da177e4
LT		 3732 pSMB->ByteCount = cpu_to_le16(count);
3733
133672ef 3734 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
7749981e 3735 0);
1da177e4 3736
1da177e4
LT		 3737 /* above now done in SendReceive */
3738 if ((rc == 0) && (tcon != NULL)) {
0e0d2cf3
SF		 3739 bool is_unicode;
3740
1da177e4 3741 tcon->tidStatus = CifsGood;
3b795210 3742 tcon->need_reconnect = false;
1da177e4
LT		 3743 tcon->tid = smb_buffer_response->Tid;
3744 bcc_ptr = pByteArea(smb_buffer_response);
690c522f 3745 bytes_left = get_bcc(smb_buffer_response);
cc20c031 3746 length = strnlen(bcc_ptr, bytes_left - 2);
0e0d2cf3
SF		 3747 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3748 is_unicode = true;
3749 else
3750 is_unicode = false;
3751
cc20c031 3752
50c2f753 3753 /* skip service field (NB: this field is always ASCII) */
7f8ed420
SF		 3754 if (length == 3) {
3755 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3756 (bcc_ptr[2] == 'C')) {
b6b38f70 3757 cFYI(1, "IPC connection");
7f8ed420
SF		 3758 tcon->ipc = 1;
3759 }
3760 } else if (length == 2) {
3761 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3762 /* the most common case */
b6b38f70 3763 cFYI(1, "disk share connection");
7f8ed420
SF		 3764 }
3765 }
50c2f753 3766 bcc_ptr += length + 1;
cc20c031 3767 bytes_left -= (length + 1);
1da177e4 3768 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
cc20c031
JL		 3769
3770 /* mostly informational -- no need to fail on error here */
90a98b2f 3771 kfree(tcon->nativeFileSystem);
acbbb76a 3772 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
0e0d2cf3 3773 bytes_left, is_unicode,
cc20c031
JL		 3774 nls_codepage);
3775
b6b38f70 3776 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
cc20c031 3777
fb8c4b14 3778 if ((smb_buffer_response->WordCount == 3) ||
1a4e15a0
SF		 3779 (smb_buffer_response->WordCount == 7))
3780 /* field is in same location */
3979877e
SF		 3781 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3782 else
3783 tcon->Flags = 0;
b6b38f70 3784 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
1da177e4 3785 } else if ((rc == 0) && tcon == NULL) {
50c2f753 3786 /* all we need to save for IPC$ connection */
1da177e4
LT		 3787 ses->ipc_tid = smb_buffer_response->Tid;
3788 }
3789
a8a11d39 3790 cifs_buf_release(smb_buffer);
1da177e4
LT		 3791 return rc;
3792}
3793
2a9b9951
AV		 3794void
3795cifs_umount(struct cifs_sb_info *cifs_sb)
1da177e4 3796{
b647c35f
JL		 3797 struct rb_root *root = &cifs_sb->tlink_tree;
3798 struct rb_node *node;
3799 struct tcon_link *tlink;
9d002df4 3800
2de970ff
JL		 3801 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3802
b647c35f
JL		 3803 spin_lock(&cifs_sb->tlink_tree_lock);
3804 while ((node = rb_first(root))) {
3805 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3806 cifs_get_tlink(tlink);
3807 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3808 rb_erase(node, root);
1da177e4 3809
b647c35f
JL		 3810 spin_unlock(&cifs_sb->tlink_tree_lock);
3811 cifs_put_tlink(tlink);
3812 spin_lock(&cifs_sb->tlink_tree_lock);
3813 }
3814 spin_unlock(&cifs_sb->tlink_tree_lock);
50c2f753 3815
dd854466 3816 bdi_destroy(&cifs_sb->bdi);
d757d71b
AV		 3817 kfree(cifs_sb->mountdata);
3818 unload_nls(cifs_sb->local_nls);
3819 kfree(cifs_sb);
50c2f753 3820}
1da177e4 3821
286170aa
PS		 3822int
3823cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
1da177e4
LT		 3824{
3825 int rc = 0;
198b5682 3826 struct TCP_Server_Info *server = ses->server;
1da177e4 3827
286170aa
PS		 3828 if (!server->ops->need_neg || !server->ops->negotiate)
3829 return -ENOSYS;
3830
198b5682 3831 /* only send once per connect */
286170aa 3832 if (!server->ops->need_neg(server))
198b5682
JL		 3833 return 0;
3834
45275789 3835 set_credits(server, 1);
286170aa
PS		 3836
3837 rc = server->ops->negotiate(xid, ses);
198b5682
JL		 3838 if (rc == 0) {
3839 spin_lock(&GlobalMid_Lock);
7fdbaa1b 3840 if (server->tcpStatus == CifsNeedNegotiate)
198b5682
JL		 3841 server->tcpStatus = CifsGood;
3842 else
3843 rc = -EHOSTDOWN;
3844 spin_unlock(&GlobalMid_Lock);
198b5682
JL		 3845 }
3846
3847 return rc;
3848}
3849
58c45c58
PS		 3850int
3851cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3852 struct nls_table *nls_info)
198b5682 3853{
58c45c58 3854 int rc = -ENOSYS;
198b5682 3855 struct TCP_Server_Info *server = ses->server;
26b994fa 3856
198b5682
JL		 3857 ses->flags = 0;
3858 ses->capabilities = server->capabilities;
26b994fa 3859 if (linuxExtEnabled == 0)
29e20f9c 3860 ses->capabilities &= (~server->vals->cap_unix);
20418acd 3861
b6b38f70 3862 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
96daf2b0 3863 server->sec_mode, server->capabilities, server->timeAdj);
cb7691b6 3864
58c45c58
PS		 3865 if (server->ops->sess_setup)
3866 rc = server->ops->sess_setup(xid, ses, nls_info);
3867
26b994fa 3868 if (rc) {
b6b38f70 3869 cERROR(1, "Send error in SessSetup = %d", rc);
26b994fa 3870 } else {
5d0d2882
SP		 3871 mutex_lock(&ses->server->srv_mutex);
3872 if (!server->session_estab) {
21e73393 3873 server->session_key.response = ses->auth_key.response;
5d0d2882 3874 server->session_key.len = ses->auth_key.len;
21e73393
SP		 3875 server->sequence_number = 0x2;
3876 server->session_estab = true;
3877 ses->auth_key.response = NULL;
5d0d2882
SP		 3878 }
3879 mutex_unlock(&server->srv_mutex);
3880
b6b38f70 3881 cFYI(1, "CIFS Session Established successfully");
20418acd 3882 spin_lock(&GlobalMid_Lock);
198b5682
JL		 3883 ses->status = CifsGood;
3884 ses->need_reconnect = false;
20418acd 3885 spin_unlock(&GlobalMid_Lock);
1da177e4 3886 }
26b994fa 3887
21e73393
SP		 3888 kfree(ses->auth_key.response);
3889 ses->auth_key.response = NULL;
3890 ses->auth_key.len = 0;
d3686d54
SP		 3891 kfree(ses->ntlmssp);
3892 ses->ntlmssp = NULL;
21e73393 3893
1da177e4
LT		 3894 return rc;
3895}
3896
8a8798a5
JL		 3897static int
3898cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3899{
3900 switch (ses->server->secType) {
3901 case Kerberos:
3902 vol->secFlg = CIFSSEC_MUST_KRB5;
3903 return 0;
3904 case NTLMv2:
3905 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3906 break;
3907 case NTLM:
3908 vol->secFlg = CIFSSEC_MUST_NTLM;
3909 break;
3910 case RawNTLMSSP:
3911 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3912 break;
3913 case LANMAN:
3914 vol->secFlg = CIFSSEC_MUST_LANMAN;
3915 break;
3916 }
3917
3918 return cifs_set_cifscreds(vol, ses);
3919}
3920
96daf2b0 3921static struct cifs_tcon *
9d002df4
JL		 3922cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3923{
8a8798a5 3924 int rc;
96daf2b0
SF		 3925 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3926 struct cifs_ses *ses;
3927 struct cifs_tcon *tcon = NULL;
9d002df4 3928 struct smb_vol *vol_info;
9d002df4
JL		 3929
3930 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
803ab977
DC		 3931 if (vol_info == NULL)
3932 return ERR_PTR(-ENOMEM);
9d002df4 3933
9d002df4
JL		 3934 vol_info->local_nls = cifs_sb->local_nls;
3935 vol_info->linux_uid = fsuid;
3936 vol_info->cred_uid = fsuid;
3937 vol_info->UNC = master_tcon->treeName;
3938 vol_info->retry = master_tcon->retry;
3939 vol_info->nocase = master_tcon->nocase;
3940 vol_info->local_lease = master_tcon->local_lease;
3941 vol_info->no_linux_ext = !master_tcon->unix_ext;
3942
8a8798a5
JL		 3943 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3944 if (rc) {
3945 tcon = ERR_PTR(rc);
3946 goto out;
3947 }
9d002df4
JL		 3948
3949 /* get a reference for the same TCP session */
3f9bcca7 3950 spin_lock(&cifs_tcp_ses_lock);
9d002df4 3951 ++master_tcon->ses->server->srv_count;
3f9bcca7 3952 spin_unlock(&cifs_tcp_ses_lock);
9d002df4
JL		 3953
3954 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3955 if (IS_ERR(ses)) {
96daf2b0 3956 tcon = (struct cifs_tcon *)ses;
9d002df4
JL		 3957 cifs_put_tcp_session(master_tcon->ses->server);
3958 goto out;
3959 }
3960
3961 tcon = cifs_get_tcon(ses, vol_info);
3962 if (IS_ERR(tcon)) {
3963 cifs_put_smb_ses(ses);
3964 goto out;
3965 }
3966
29e20f9c 3967 if (cap_unix(ses))
9d002df4
JL		 3968 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3969out:
8a8798a5
JL		 3970 kfree(vol_info->username);
3971 kfree(vol_info->password);
9d002df4
JL		 3972 kfree(vol_info);
3973
3974 return tcon;
3975}
3976
96daf2b0 3977struct cifs_tcon *
9d002df4
JL		 3978cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3979{
3980 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3981}
3982
3983static int
3984cifs_sb_tcon_pending_wait(void *unused)
3985{
3986 schedule();
3987 return signal_pending(current) ? -ERESTARTSYS : 0;
3988}
3989
b647c35f
JL		 3990/* find and return a tlink with given uid */
3991static struct tcon_link *
3992tlink_rb_search(struct rb_root *root, uid_t uid)
3993{
3994 struct rb_node *node = root->rb_node;
3995 struct tcon_link *tlink;
3996
3997 while (node) {
3998 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3999
4000 if (tlink->tl_uid > uid)
4001 node = node->rb_left;
4002 else if (tlink->tl_uid < uid)
4003 node = node->rb_right;
4004 else
4005 return tlink;
4006 }
4007 return NULL;
4008}
4009
4010/* insert a tcon_link into the tree */
4011static void
4012tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4013{
4014 struct rb_node **new = &(root->rb_node), *parent = NULL;
4015 struct tcon_link *tlink;
4016
4017 while (*new) {
4018 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4019 parent = *new;
4020
4021 if (tlink->tl_uid > new_tlink->tl_uid)
4022 new = &((*new)->rb_left);
4023 else
4024 new = &((*new)->rb_right);
4025 }
4026
4027 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4028 rb_insert_color(&new_tlink->tl_rbnode, root);
4029}
4030
9d002df4
JL		 4031/*
4032 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4033 * current task.
4034 *
4035 * If the superblock doesn't refer to a multiuser mount, then just return
4036 * the master tcon for the mount.
4037 *
6ef933a3 4038 * First, search the rbtree for an existing tcon for this fsuid. If one
9d002df4
JL		 4039 * exists, then check to see if it's pending construction. If it is then wait
4040 * for construction to complete. Once it's no longer pending, check to see if
4041 * it failed and either return an error or retry construction, depending on
4042 * the timeout.
4043 *
4044 * If one doesn't exist then insert a new tcon_link struct into the tree and
4045 * try to construct a new one.
4046 */
4047struct tcon_link *
4048cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4049{
4050 int ret;
b647c35f 4051 uid_t fsuid = current_fsuid();
9d002df4
JL		 4052 struct tcon_link *tlink, *newtlink;
4053
4054 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4055 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4056
4057 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 4058 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4059 if (tlink)
4060 cifs_get_tlink(tlink);
4061 spin_unlock(&cifs_sb->tlink_tree_lock);
4062
4063 if (tlink == NULL) {
4064 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4065 if (newtlink == NULL)
4066 return ERR_PTR(-ENOMEM);
b647c35f 4067 newtlink->tl_uid = fsuid;
9d002df4
JL		 4068 newtlink->tl_tcon = ERR_PTR(-EACCES);
4069 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4070 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4071 cifs_get_tlink(newtlink);
4072
9d002df4
JL		 4073 spin_lock(&cifs_sb->tlink_tree_lock);
4074 /* was one inserted after previous search? */
b647c35f 4075 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4076 if (tlink) {
4077 cifs_get_tlink(tlink);
4078 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4079 kfree(newtlink);
4080 goto wait_for_construction;
4081 }
9d002df4 4082 tlink = newtlink;
b647c35f
JL		 4083 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4084 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4085 } else {
4086wait_for_construction:
4087 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4088 cifs_sb_tcon_pending_wait,
4089 TASK_INTERRUPTIBLE);
4090 if (ret) {
4091 cifs_put_tlink(tlink);
4092 return ERR_PTR(ret);
4093 }
4094
4095 /* if it's good, return it */
4096 if (!IS_ERR(tlink->tl_tcon))
4097 return tlink;
4098
4099 /* return error if we tried this already recently */
4100 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4101 cifs_put_tlink(tlink);
4102 return ERR_PTR(-EACCES);
4103 }
4104
4105 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4106 goto wait_for_construction;
4107 }
4108
4109 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4110 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4111 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4112
4113 if (IS_ERR(tlink->tl_tcon)) {
4114 cifs_put_tlink(tlink);
4115 return ERR_PTR(-EACCES);
4116 }
4117
4118 return tlink;
4119}
2de970ff
JL		 4120
4121/*
4122 * periodic workqueue job that scans tcon_tree for a superblock and closes
4123 * out tcons.
4124 */
4125static void
4126cifs_prune_tlinks(struct work_struct *work)
4127{
4128 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4129 prune_tlinks.work);
b647c35f
JL		 4130 struct rb_root *root = &cifs_sb->tlink_tree;
4131 struct rb_node *node = rb_first(root);
4132 struct rb_node *tmp;
4133 struct tcon_link *tlink;
2de970ff 4134
b647c35f
JL		 4135 /*
4136 * Because we drop the spinlock in the loop in order to put the tlink
4137 * it's not guarded against removal of links from the tree. The only
4138 * places that remove entries from the tree are this function and
4139 * umounts. Because this function is non-reentrant and is canceled
4140 * before umount can proceed, this is safe.
4141 */
4142 spin_lock(&cifs_sb->tlink_tree_lock);
4143 node = rb_first(root);
4144 while (node != NULL) {
4145 tmp = node;
4146 node = rb_next(tmp);
4147 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4148
4149 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4150 atomic_read(&tlink->tl_count) != 0 ||
4151 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4152 continue;
2de970ff 4153
b647c35f
JL		 4154 cifs_get_tlink(tlink);
4155 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4156 rb_erase(tmp, root);
4157
4158 spin_unlock(&cifs_sb->tlink_tree_lock);
4159 cifs_put_tlink(tlink);
4160 spin_lock(&cifs_sb->tlink_tree_lock);
4161 }
4162 spin_unlock(&cifs_sb->tlink_tree_lock);
2de970ff 4163
da472fc8 4164 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 4165 TLINK_IDLE_EXPIRE);
4166}
kernel source for telekom puls (alcatel/mediatek)