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