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