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