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