projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cifs: add new fields to cifs_ses to track requested security flavor
[deliverable/linux.git] / fs / cifs / connect.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/connect.c
3 *
1080ef75 4 * Copyright (C) International Business Machines Corp., 2002,2011
1da177e4
LT		 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
fb8c4b14 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1da177e4
LT		 20 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
b8643e1b 31#include <linux/delay.h>
f191401f 32#include <linux/completion.h>
aaf737ad 33#include <linux/kthread.h>
0ae0efad 34#include <linux/pagevec.h>
7dfb7103 35#include <linux/freezer.h>
5c2503a8 36#include <linux/namei.h>
1da177e4
LT		 37#include <asm/uaccess.h>
38#include <asm/processor.h>
50b64e3b 39#include <linux/inet.h>
143cb494 40#include <linux/module.h>
8a8798a5 41#include <keys/user-type.h>
0e2bedaa 42#include <net/ipv6.h>
8830d7e0
SP		 43#include <linux/parser.h>
44
1da177e4
LT		 45#include "cifspdu.h"
46#include "cifsglob.h"
47#include "cifsproto.h"
48#include "cifs_unicode.h"
49#include "cifs_debug.h"
50#include "cifs_fs_sb.h"
51#include "ntlmssp.h"
52#include "nterr.h"
53#include "rfc1002pdu.h"
488f1d2d 54#include "fscache.h"
1da177e4
LT		 55
56#define CIFS_PORT 445
57#define RFC1001_PORT 139
58
1da177e4
LT		 59extern mempool_t *cifs_req_poolp;
60
2de970ff 61/* FIXME: should these be tunable? */
9d002df4 62#define TLINK_ERROR_EXPIRE (1 * HZ)
2de970ff 63#define TLINK_IDLE_EXPIRE (600 * HZ)
9d002df4 64
8830d7e0
SP		 65enum {
66
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
72bd481f 70 Opt_forcegid, Opt_noforcegid,
8830d7e0
SP		 71 Opt_noblocksend, Opt_noautotune,
72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
76 Opt_nocase,
77 Opt_brl, Opt_nobrl,
78 Opt_forcemandatorylock, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
81 Opt_nointr, Opt_intr,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
1b359204 86 Opt_sign, Opt_seal, Opt_noac,
8830d7e0 87 Opt_fsc, Opt_mfsymlinks,
a0b3df5c 88 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
8830d7e0
SP		 89
90 /* Mount options which take numeric value */
91 Opt_backupuid, Opt_backupgid, Opt_uid,
92 Opt_cruid, Opt_gid, Opt_file_mode,
93 Opt_dirmode, Opt_port,
94 Opt_rsize, Opt_wsize, Opt_actimeo,
95
96 /* Mount options which take string value */
97 Opt_user, Opt_pass, Opt_ip,
73a999fa 98 Opt_domain, Opt_srcaddr, Opt_iocharset,
8830d7e0 99 Opt_netbiosname, Opt_servern,
23db65f5 100 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
8830d7e0
SP		 101
102 /* Mount options to be ignored */
103 Opt_ignore,
104
105 /* Options which could be blank */
106 Opt_blank_pass,
4fe9e963
SP		 107 Opt_blank_user,
108 Opt_blank_ip,
8830d7e0
SP		 109
110 Opt_err
111};
112
113static const match_table_t cifs_mount_option_tokens = {
114
115 { Opt_user_xattr, "user_xattr" },
116 { Opt_nouser_xattr, "nouser_xattr" },
117 { Opt_forceuid, "forceuid" },
118 { Opt_noforceuid, "noforceuid" },
72bd481f
JL		 119 { Opt_forcegid, "forcegid" },
120 { Opt_noforcegid, "noforcegid" },
8830d7e0
SP		 121 { Opt_noblocksend, "noblocksend" },
122 { Opt_noautotune, "noautotune" },
123 { Opt_hard, "hard" },
124 { Opt_soft, "soft" },
125 { Opt_perm, "perm" },
126 { Opt_noperm, "noperm" },
127 { Opt_mapchars, "mapchars" },
128 { Opt_nomapchars, "nomapchars" },
129 { Opt_sfu, "sfu" },
130 { Opt_nosfu, "nosfu" },
131 { Opt_nodfs, "nodfs" },
132 { Opt_posixpaths, "posixpaths" },
133 { Opt_noposixpaths, "noposixpaths" },
134 { Opt_nounix, "nounix" },
135 { Opt_nounix, "nolinux" },
136 { Opt_nocase, "nocase" },
137 { Opt_nocase, "ignorecase" },
138 { Opt_brl, "brl" },
139 { Opt_nobrl, "nobrl" },
140 { Opt_nobrl, "nolock" },
141 { Opt_forcemandatorylock, "forcemandatorylock" },
5cfdddcf 142 { Opt_forcemandatorylock, "forcemand" },
8830d7e0
SP		 143 { Opt_setuids, "setuids" },
144 { Opt_nosetuids, "nosetuids" },
145 { Opt_dynperm, "dynperm" },
146 { Opt_nodynperm, "nodynperm" },
147 { Opt_nohard, "nohard" },
148 { Opt_nosoft, "nosoft" },
149 { Opt_nointr, "nointr" },
150 { Opt_intr, "intr" },
151 { Opt_nostrictsync, "nostrictsync" },
152 { Opt_strictsync, "strictsync" },
153 { Opt_serverino, "serverino" },
154 { Opt_noserverino, "noserverino" },
155 { Opt_rwpidforward, "rwpidforward" },
156 { Opt_cifsacl, "cifsacl" },
157 { Opt_nocifsacl, "nocifsacl" },
158 { Opt_acl, "acl" },
159 { Opt_noacl, "noacl" },
160 { Opt_locallease, "locallease" },
161 { Opt_sign, "sign" },
162 { Opt_seal, "seal" },
8830d7e0
SP		 163 { Opt_noac, "noac" },
164 { Opt_fsc, "fsc" },
165 { Opt_mfsymlinks, "mfsymlinks" },
166 { Opt_multiuser, "multiuser" },
d8162558 167 { Opt_sloppy, "sloppy" },
a0b3df5c 168 { Opt_nosharesock, "nosharesock" },
8830d7e0
SP		 169
170 { Opt_backupuid, "backupuid=%s" },
171 { Opt_backupgid, "backupgid=%s" },
172 { Opt_uid, "uid=%s" },
173 { Opt_cruid, "cruid=%s" },
174 { Opt_gid, "gid=%s" },
175 { Opt_file_mode, "file_mode=%s" },
176 { Opt_dirmode, "dirmode=%s" },
177 { Opt_dirmode, "dir_mode=%s" },
178 { Opt_port, "port=%s" },
179 { Opt_rsize, "rsize=%s" },
180 { Opt_wsize, "wsize=%s" },
181 { Opt_actimeo, "actimeo=%s" },
182
4fe9e963
SP		 183 { Opt_blank_user, "user=" },
184 { Opt_blank_user, "username=" },
8830d7e0
SP		 185 { Opt_user, "user=%s" },
186 { Opt_user, "username=%s" },
187 { Opt_blank_pass, "pass=" },
3c15b4cf 188 { Opt_blank_pass, "password=" },
8830d7e0
SP		 189 { Opt_pass, "pass=%s" },
190 { Opt_pass, "password=%s" },
4fe9e963
SP		 191 { Opt_blank_ip, "ip=" },
192 { Opt_blank_ip, "addr=" },
8830d7e0
SP		 193 { Opt_ip, "ip=%s" },
194 { Opt_ip, "addr=%s" },
73a999fa
JL		 195 { Opt_ignore, "unc=%s" },
196 { Opt_ignore, "target=%s" },
197 { Opt_ignore, "path=%s" },
8830d7e0
SP		 198 { Opt_domain, "dom=%s" },
199 { Opt_domain, "domain=%s" },
200 { Opt_domain, "workgroup=%s" },
201 { Opt_srcaddr, "srcaddr=%s" },
73a999fa 202 { Opt_ignore, "prefixpath=%s" },
8830d7e0 203 { Opt_iocharset, "iocharset=%s" },
8830d7e0
SP		 204 { Opt_netbiosname, "netbiosname=%s" },
205 { Opt_servern, "servern=%s" },
206 { Opt_ver, "ver=%s" },
23db65f5 207 { Opt_vers, "vers=%s" },
8830d7e0 208 { Opt_sec, "sec=%s" },
15b6a473 209 { Opt_cache, "cache=%s" },
8830d7e0
SP		 210
211 { Opt_ignore, "cred" },
212 { Opt_ignore, "credentials" },
a557b976
JL		 213 { Opt_ignore, "cred=%s" },
214 { Opt_ignore, "credentials=%s" },
8830d7e0
SP		 215 { Opt_ignore, "guest" },
216 { Opt_ignore, "rw" },
217 { Opt_ignore, "ro" },
218 { Opt_ignore, "suid" },
219 { Opt_ignore, "nosuid" },
220 { Opt_ignore, "exec" },
221 { Opt_ignore, "noexec" },
222 { Opt_ignore, "nodev" },
223 { Opt_ignore, "noauto" },
224 { Opt_ignore, "dev" },
225 { Opt_ignore, "mand" },
226 { Opt_ignore, "nomand" },
227 { Opt_ignore, "_netdev" },
228
229 { Opt_err, NULL }
230};
231
232enum {
233 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
234 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
7659624f
JL		 235 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
236 Opt_sec_ntlmv2i, Opt_sec_lanman,
8830d7e0
SP		 237 Opt_sec_none,
238
239 Opt_sec_err
240};
241
242static const match_table_t cifs_secflavor_tokens = {
243 { Opt_sec_krb5, "krb5" },
244 { Opt_sec_krb5i, "krb5i" },
245 { Opt_sec_krb5p, "krb5p" },
246 { Opt_sec_ntlmsspi, "ntlmsspi" },
247 { Opt_sec_ntlmssp, "ntlmssp" },
248 { Opt_ntlm, "ntlm" },
249 { Opt_sec_ntlmi, "ntlmi" },
7659624f
JL		 250 { Opt_sec_ntlmv2, "nontlm" },
251 { Opt_sec_ntlmv2, "ntlmv2" },
8830d7e0 252 { Opt_sec_ntlmv2i, "ntlmv2i" },
8830d7e0
SP		 253 { Opt_sec_lanman, "lanman" },
254 { Opt_sec_none, "none" },
255
256 { Opt_sec_err, NULL }
257};
258
15b6a473
JL		 259/* cache flavors */
260enum {
261 Opt_cache_loose,
262 Opt_cache_strict,
263 Opt_cache_none,
264 Opt_cache_err
265};
266
267static const match_table_t cifs_cacheflavor_tokens = {
268 { Opt_cache_loose, "loose" },
269 { Opt_cache_strict, "strict" },
270 { Opt_cache_none, "none" },
271 { Opt_cache_err, NULL }
272};
273
23db65f5
JL		 274static const match_table_t cifs_smb_version_tokens = {
275 { Smb_1, SMB1_VERSION_STRING },
dd446b16 276 { Smb_20, SMB20_VERSION_STRING},
1080ef75 277 { Smb_21, SMB21_VERSION_STRING },
e4aa25e7 278 { Smb_30, SMB30_VERSION_STRING },
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 2503 ses->overrideSecFlg = volume_info->secFlg;
28e11bd8
JL		 2504 ses->sectype = volume_info->sectype;
2505 ses->sign = volume_info->sign;
36988c76
JL		 2506
2507 mutex_lock(&ses->session_mutex);
198b5682
JL		 2508 rc = cifs_negotiate_protocol(xid, ses);
2509 if (!rc)
2510 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
36988c76 2511 mutex_unlock(&ses->session_mutex);
c8e56f1f 2512 if (rc)
36988c76
JL		 2513 goto get_ses_fail;
2514
2515 /* success, put it on the list */
3f9bcca7 2516 spin_lock(&cifs_tcp_ses_lock);
36988c76 2517 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3f9bcca7 2518 spin_unlock(&cifs_tcp_ses_lock);
36988c76 2519
6d5786a3 2520 free_xid(xid);
36988c76
JL		 2521 return ses;
2522
2523get_ses_fail:
2524 sesInfoFree(ses);
6d5786a3 2525 free_xid(xid);
36988c76
JL		 2526 return ERR_PTR(rc);
2527}
2528
96daf2b0 2529static int match_tcon(struct cifs_tcon *tcon, const char *unc)
37bb04e5
PS		 2530{
2531 if (tcon->tidStatus == CifsExiting)
2532 return 0;
2533 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2534 return 0;
2535 return 1;
2536}
2537
96daf2b0
SF		 2538static struct cifs_tcon *
2539cifs_find_tcon(struct cifs_ses *ses, const char *unc)
f1987b44
JL		 2540{
2541 struct list_head *tmp;
96daf2b0 2542 struct cifs_tcon *tcon;
f1987b44 2543
3f9bcca7 2544 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2545 list_for_each(tmp, &ses->tcon_list) {
96daf2b0 2546 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
37bb04e5 2547 if (!match_tcon(tcon, unc))
f1987b44 2548 continue;
f1987b44 2549 ++tcon->tc_count;
3f9bcca7 2550 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2551 return tcon;
1da177e4 2552 }
3f9bcca7 2553 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2554 return NULL;
2555}
2556
f1987b44 2557static void
96daf2b0 2558cifs_put_tcon(struct cifs_tcon *tcon)
f1987b44 2559{
2e6e02ab 2560 unsigned int xid;
96daf2b0 2561 struct cifs_ses *ses = tcon->ses;
f1987b44 2562
f96637be 2563 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3f9bcca7 2564 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2565 if (--tcon->tc_count > 0) {
3f9bcca7 2566 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2567 return;
2568 }
2569
2570 list_del_init(&tcon->tcon_list);
3f9bcca7 2571 spin_unlock(&cifs_tcp_ses_lock);
f1987b44 2572
6d5786a3 2573 xid = get_xid();
2e6e02ab
PS		 2574 if (ses->server->ops->tree_disconnect)
2575 ses->server->ops->tree_disconnect(xid, tcon);
6d5786a3 2576 _free_xid(xid);
f1987b44 2577
d03382ce 2578 cifs_fscache_release_super_cookie(tcon);
9f841593 2579 tconInfoFree(tcon);
f1987b44
JL		 2580 cifs_put_smb_ses(ses);
2581}
2582
96daf2b0
SF		 2583static struct cifs_tcon *
2584cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
d00c28de
JL		 2585{
2586 int rc, xid;
96daf2b0 2587 struct cifs_tcon *tcon;
d00c28de
JL		 2588
2589 tcon = cifs_find_tcon(ses, volume_info->UNC);
2590 if (tcon) {
f96637be 2591 cifs_dbg(FYI, "Found match on UNC path\n");
d00c28de
JL		 2592 /* existing tcon already has a reference */
2593 cifs_put_smb_ses(ses);
2594 if (tcon->seal != volume_info->seal)
f96637be 2595 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
d00c28de
JL		 2596 return tcon;
2597 }
2598
2e6e02ab
PS		 2599 if (!ses->server->ops->tree_connect) {
2600 rc = -ENOSYS;
2601 goto out_fail;
2602 }
2603
d00c28de
JL		 2604 tcon = tconInfoAlloc();
2605 if (tcon == NULL) {
2606 rc = -ENOMEM;
2607 goto out_fail;
2608 }
2609
2610 tcon->ses = ses;
2611 if (volume_info->password) {
2612 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2613 if (!tcon->password) {
2614 rc = -ENOMEM;
2615 goto out_fail;
2616 }
2617 }
2618
2e6e02ab
PS		 2619 /*
2620 * BB Do we need to wrap session_mutex around this TCon call and Unix
2621 * SetFS as we do on SessSetup and reconnect?
2622 */
6d5786a3 2623 xid = get_xid();
2e6e02ab
PS		 2624 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2625 volume_info->local_nls);
6d5786a3 2626 free_xid(xid);
f96637be 2627 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
d00c28de
JL		 2628 if (rc)
2629 goto out_fail;
2630
2631 if (volume_info->nodfs) {
2632 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
f96637be 2633 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
d00c28de
JL		 2634 }
2635 tcon->seal = volume_info->seal;
2e6e02ab
PS		 2636 /*
2637 * We can have only one retry value for a connection to a share so for
2638 * resources mounted more than once to the same server share the last
2639 * value passed in for the retry flag is used.
2640 */
d00c28de
JL		 2641 tcon->retry = volume_info->retry;
2642 tcon->nocase = volume_info->nocase;
2643 tcon->local_lease = volume_info->local_lease;
233839b1 2644 INIT_LIST_HEAD(&tcon->pending_opens);
d00c28de 2645
3f9bcca7 2646 spin_lock(&cifs_tcp_ses_lock);
d00c28de 2647 list_add(&tcon->tcon_list, &ses->tcon_list);
3f9bcca7 2648 spin_unlock(&cifs_tcp_ses_lock);
d00c28de 2649
d03382ce
SJ		 2650 cifs_fscache_get_super_cookie(tcon);
2651
d00c28de
JL		 2652 return tcon;
2653
2654out_fail:
2655 tconInfoFree(tcon);
2656 return ERR_PTR(rc);
2657}
2658
9d002df4
JL		 2659void
2660cifs_put_tlink(struct tcon_link *tlink)
2661{
2662 if (!tlink || IS_ERR(tlink))
2663 return;
2664
2665 if (!atomic_dec_and_test(&tlink->tl_count) ||
2666 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2667 tlink->tl_time = jiffies;
2668 return;
2669 }
2670
2671 if (!IS_ERR(tlink_tcon(tlink)))
2672 cifs_put_tcon(tlink_tcon(tlink));
2673 kfree(tlink);
2674 return;
2675}
d00c28de 2676
25c7f41e 2677static inline struct tcon_link *
cd51875d
PS		 2678cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2679{
2680 return cifs_sb->master_tlink;
2681}
25c7f41e
PS		 2682
2683static int
2684compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2685{
2686 struct cifs_sb_info *old = CIFS_SB(sb);
2687 struct cifs_sb_info *new = mnt_data->cifs_sb;
2688
2689 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2690 return 0;
2691
2692 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2693 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2694 return 0;
2695
25c7f41e 2696 /*
5eba8ab3
JL		 2697 * We want to share sb only if we don't specify an r/wsize or
2698 * specified r/wsize is greater than or equal to existing one.
25c7f41e
PS		 2699 */
2700 if (new->wsize && new->wsize < old->wsize)
2701 return 0;
2702
5eba8ab3
JL		 2703 if (new->rsize && new->rsize < old->rsize)
2704 return 0;
2705
1f68233c 2706 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
25c7f41e
PS		 2707 return 0;
2708
2709 if (old->mnt_file_mode != new->mnt_file_mode ||
2710 old->mnt_dir_mode != new->mnt_dir_mode)
2711 return 0;
2712
2713 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2714 return 0;
2715
2716 if (old->actimeo != new->actimeo)
2717 return 0;
2718
2719 return 1;
2720}
2721
2722int
2723cifs_match_super(struct super_block *sb, void *data)
2724{
2725 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2726 struct smb_vol *volume_info;
2727 struct cifs_sb_info *cifs_sb;
2728 struct TCP_Server_Info *tcp_srv;
96daf2b0
SF		 2729 struct cifs_ses *ses;
2730 struct cifs_tcon *tcon;
25c7f41e 2731 struct tcon_link *tlink;
25c7f41e
PS		 2732 int rc = 0;
2733
25c7f41e
PS		 2734 spin_lock(&cifs_tcp_ses_lock);
2735 cifs_sb = CIFS_SB(sb);
2736 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2737 if (IS_ERR(tlink)) {
2738 spin_unlock(&cifs_tcp_ses_lock);
2739 return rc;
2740 }
2741 tcon = tlink_tcon(tlink);
2742 ses = tcon->ses;
2743 tcp_srv = ses->server;
2744
2745 volume_info = mnt_data->vol;
2746
9fa114f7 2747 if (!match_server(tcp_srv, volume_info) ||
25c7f41e
PS		 2748 !match_session(ses, volume_info) ||
2749 !match_tcon(tcon, volume_info->UNC)) {
2750 rc = 0;
2751 goto out;
2752 }
2753
2754 rc = compare_mount_options(sb, mnt_data);
2755out:
25c7f41e 2756 spin_unlock(&cifs_tcp_ses_lock);
f484b5d0 2757 cifs_put_tlink(tlink);
25c7f41e
PS		 2758 return rc;
2759}
2760
1da177e4 2761int
b669f33c 2762get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2e6e02ab
PS		 2763 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2764 struct dfs_info3_param **referrals, int remap)
1da177e4
LT		 2765{
2766 char *temp_unc;
2767 int rc = 0;
2768
b669f33c 2769 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2e6e02ab
PS		 2770 return -ENOSYS;
2771
2772 *num_referrals = 0;
2773 *referrals = NULL;
1da177e4 2774
2e6e02ab 2775 if (ses->ipc_tid == 0) {
1da177e4 2776 temp_unc = kmalloc(2 /* for slashes */ +
2e6e02ab
PS		 2777 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2778 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
1da177e4
LT		 2779 if (temp_unc == NULL)
2780 return -ENOMEM;
2781 temp_unc[0] = '\\';
2782 temp_unc[1] = '\\';
2e6e02ab
PS		 2783 strcpy(temp_unc + 2, ses->serverName);
2784 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2785 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2786 nls_codepage);
f96637be 2787 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
1da177e4
LT		 2788 kfree(temp_unc);
2789 }
2790 if (rc == 0)
b669f33c
PS		 2791 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2792 referrals, num_referrals,
2793 nls_codepage, remap);
2e6e02ab
PS		 2794 /*
2795 * BB - map targetUNCs to dfs_info3 structures, here or in
b669f33c 2796 * ses->server->ops->get_dfs_refer.
2e6e02ab 2797 */
1da177e4
LT		 2798
2799 return rc;
2800}
2801
09e50d55
JL		 2802#ifdef CONFIG_DEBUG_LOCK_ALLOC
2803static struct lock_class_key cifs_key[2];
2804static struct lock_class_key cifs_slock_key[2];
2805
2806static inline void
2807cifs_reclassify_socket4(struct socket *sock)
2808{
2809 struct sock *sk = sock->sk;
2810 BUG_ON(sock_owned_by_user(sk));
2811 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2812 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2813}
2814
2815static inline void
2816cifs_reclassify_socket6(struct socket *sock)
2817{
2818 struct sock *sk = sock->sk;
2819 BUG_ON(sock_owned_by_user(sk));
2820 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2821 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2822}
2823#else
2824static inline void
2825cifs_reclassify_socket4(struct socket *sock)
2826{
2827}
2828
2829static inline void
2830cifs_reclassify_socket6(struct socket *sock)
2831{
2832}
2833#endif
2834
1da177e4 2835/* See RFC1001 section 14 on representation of Netbios names */
50c2f753 2836static void rfc1002mangle(char *target, char *source, unsigned int length)
1da177e4 2837{
50c2f753 2838 unsigned int i, j;
1da177e4 2839
50c2f753 2840 for (i = 0, j = 0; i < (length); i++) {
1da177e4
LT		 2841 /* mask a nibble at a time and encode */
2842 target[j] = 'A' + (0x0F & (source[i] >> 4));
2843 target[j+1] = 'A' + (0x0F & source[i]);
50c2f753 2844 j += 2;
1da177e4
LT		 2845 }
2846
2847}
2848
3eb9a889
BG		 2849static int
2850bind_socket(struct TCP_Server_Info *server)
2851{
2852 int rc = 0;
2853 if (server->srcaddr.ss_family != AF_UNSPEC) {
2854 /* Bind to the specified local IP address */
2855 struct socket *socket = server->ssocket;
2856 rc = socket->ops->bind(socket,
2857 (struct sockaddr *) &server->srcaddr,
2858 sizeof(server->srcaddr));
2859 if (rc < 0) {
2860 struct sockaddr_in *saddr4;
2861 struct sockaddr_in6 *saddr6;
2862 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2863 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2864 if (saddr6->sin6_family == AF_INET6)
f96637be
JP		 2865 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2866 &saddr6->sin6_addr, rc);
3eb9a889 2867 else
f96637be
JP		 2868 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2869 &saddr4->sin_addr.s_addr, rc);
3eb9a889
BG		 2870 }
2871 }
2872 return rc;
2873}
1da177e4
LT		 2874
2875static int
a9f1b85e 2876ip_rfc1001_connect(struct TCP_Server_Info *server)
1da177e4
LT		 2877{
2878 int rc = 0;
a9f1b85e
PS		 2879 /*
2880 * some servers require RFC1001 sessinit before sending
2881 * negprot - BB check reconnection in case where second
2882 * sessinit is sent but no second negprot
2883 */
2884 struct rfc1002_session_packet *ses_init_buf;
2885 struct smb_hdr *smb_buf;
2886 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2887 GFP_KERNEL);
2888 if (ses_init_buf) {
2889 ses_init_buf->trailer.session_req.called_len = 32;
2890
2891 if (server->server_RFC1001_name &&
2892 server->server_RFC1001_name[0] != 0)
2893 rfc1002mangle(ses_init_buf->trailer.
2894 session_req.called_name,
2895 server->server_RFC1001_name,
2896 RFC1001_NAME_LEN_WITH_NULL);
2897 else
2898 rfc1002mangle(ses_init_buf->trailer.
2899 session_req.called_name,
2900 DEFAULT_CIFS_CALLED_NAME,
2901 RFC1001_NAME_LEN_WITH_NULL);
2902
2903 ses_init_buf->trailer.session_req.calling_len = 32;
2904
2905 /*
2906 * calling name ends in null (byte 16) from old smb
2907 * convention.
2908 */
2909 if (server->workstation_RFC1001_name &&
2910 server->workstation_RFC1001_name[0] != 0)
2911 rfc1002mangle(ses_init_buf->trailer.
2912 session_req.calling_name,
2913 server->workstation_RFC1001_name,
2914 RFC1001_NAME_LEN_WITH_NULL);
2915 else
2916 rfc1002mangle(ses_init_buf->trailer.
2917 session_req.calling_name,
2918 "LINUX_CIFS_CLNT",
2919 RFC1001_NAME_LEN_WITH_NULL);
2920
2921 ses_init_buf->trailer.session_req.scope1 = 0;
2922 ses_init_buf->trailer.session_req.scope2 = 0;
2923 smb_buf = (struct smb_hdr *)ses_init_buf;
2924
2925 /* sizeof RFC1002_SESSION_REQUEST with no scope */
be8e3b00 2926 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
a9f1b85e
PS		 2927 rc = smb_send(server, smb_buf, 0x44);
2928 kfree(ses_init_buf);
2929 /*
2930 * RFC1001 layer in at least one server
2931 * requires very short break before negprot
2932 * presumably because not expecting negprot
2933 * to follow so fast. This is a simple
2934 * solution that works without
2935 * complicating the code and causes no
2936 * significant slowing down on mount
2937 * for everyone else
2938 */
2939 usleep_range(1000, 2000);
2940 }
2941 /*
2942 * else the negprot may still work without this
2943 * even though malloc failed
2944 */
2945
2946 return rc;
2947}
2948
2949static int
2950generic_ip_connect(struct TCP_Server_Info *server)
2951{
2952 int rc = 0;
6da97910 2953 __be16 sport;
a9f1b85e 2954 int slen, sfamily;
bcf4b106 2955 struct socket *socket = server->ssocket;
a9f1b85e
PS		 2956 struct sockaddr *saddr;
2957
2958 saddr = (struct sockaddr *) &server->dstaddr;
2959
2960 if (server->dstaddr.ss_family == AF_INET6) {
2961 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2962 slen = sizeof(struct sockaddr_in6);
2963 sfamily = AF_INET6;
2964 } else {
2965 sport = ((struct sockaddr_in *) saddr)->sin_port;
2966 slen = sizeof(struct sockaddr_in);
2967 sfamily = AF_INET;
2968 }
1da177e4 2969
bcf4b106 2970 if (socket == NULL) {
f1d0c998
RL		 2971 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2972 IPPROTO_TCP, &socket, 1);
1da177e4 2973 if (rc < 0) {
f96637be 2974 cifs_dbg(VFS, "Error %d creating socket\n", rc);
a9f1b85e 2975 server->ssocket = NULL;
1da177e4 2976 return rc;
1da177e4 2977 }
bcf4b106
JL		 2978
2979 /* BB other socket options to set KEEPALIVE, NODELAY? */
f96637be 2980 cifs_dbg(FYI, "Socket created\n");
bcf4b106
JL		 2981 server->ssocket = socket;
2982 socket->sk->sk_allocation = GFP_NOFS;
a9f1b85e
PS		 2983 if (sfamily == AF_INET6)
2984 cifs_reclassify_socket6(socket);
2985 else
2986 cifs_reclassify_socket4(socket);
1da177e4
LT		 2987 }
2988
3eb9a889
BG		 2989 rc = bind_socket(server);
2990 if (rc < 0)
2991 return rc;
2992
bcf4b106
JL		 2993 /*
2994 * Eventually check for other socket options to change from
a9f1b85e
PS		 2995 * the default. sock_setsockopt not used because it expects
2996 * user space buffer
bcf4b106
JL		 2997 */
2998 socket->sk->sk_rcvtimeo = 7 * HZ;
da505c38 2999 socket->sk->sk_sndtimeo = 5 * HZ;
edf1ae40 3000
b387eaeb 3001 /* make the bufsizes depend on wsize/rsize and max requests */
bcf4b106
JL		 3002 if (server->noautotune) {
3003 if (socket->sk->sk_sndbuf < (200 * 1024))
3004 socket->sk->sk_sndbuf = 200 * 1024;
3005 if (socket->sk->sk_rcvbuf < (140 * 1024))
3006 socket->sk->sk_rcvbuf = 140 * 1024;
edf1ae40 3007 }
1da177e4 3008
6a5fa236 3009 if (server->tcp_nodelay) {
a9f1b85e 3010 int val = 1;
6a5fa236
SF		 3011 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3012 (char *)&val, sizeof(val));
3013 if (rc)
f96637be
JP		 3014 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3015 rc);
6a5fa236
SF		 3016 }
3017
f96637be 3018 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
bcf4b106 3019 socket->sk->sk_sndbuf,
b6b38f70 3020 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
bcf4b106 3021
ee1b3ea9
JL		 3022 rc = socket->ops->connect(socket, saddr, slen, 0);
3023 if (rc < 0) {
f96637be 3024 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
ee1b3ea9
JL		 3025 sock_release(socket);
3026 server->ssocket = NULL;
3027 return rc;
3028 }
3029
a9f1b85e
PS		 3030 if (sport == htons(RFC1001_PORT))
3031 rc = ip_rfc1001_connect(server);
50c2f753 3032
1da177e4
LT		 3033 return rc;
3034}
3035
3036static int
a9f1b85e 3037ip_connect(struct TCP_Server_Info *server)
1da177e4 3038{
6da97910 3039 __be16 *sport;
a9f1b85e
PS		 3040 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3041 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1da177e4 3042
a9f1b85e
PS		 3043 if (server->dstaddr.ss_family == AF_INET6)
3044 sport = &addr6->sin6_port;
3045 else
3046 sport = &addr->sin_port;
1da177e4 3047
a9f1b85e
PS		 3048 if (*sport == 0) {
3049 int rc;
1da177e4 3050
a9f1b85e
PS		 3051 /* try with 445 port at first */
3052 *sport = htons(CIFS_PORT);
3eb9a889 3053
a9f1b85e 3054 rc = generic_ip_connect(server);
1da177e4 3055 if (rc >= 0)
a9f1b85e 3056 return rc;
6a5fa236 3057
a9f1b85e
PS		 3058 /* if it failed, try with 139 port */
3059 *sport = htons(RFC1001_PORT);
6a5fa236
SF		 3060 }
3061
a9f1b85e 3062 return generic_ip_connect(server);
1da177e4
LT		 3063}
3064
6d5786a3 3065void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2c6292ae 3066 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
8af18971
SF		 3067{
3068 /* if we are reconnecting then should we check to see if
3069 * any requested capabilities changed locally e.g. via
3070 * remount but we can not do much about it here
3071 * if they have (even if we could detect it by the following)
3072 * Perhaps we could add a backpointer to array of sb from tcon
3073 * or if we change to make all sb to same share the same
3074 * sb as NFS - then we only have one backpointer to sb.
3075 * What if we wanted to mount the server share twice once with
3076 * and once without posixacls or posix paths? */
3077 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
50c2f753 3078
c18c842b
SF		 3079 if (vol_info && vol_info->no_linux_ext) {
3080 tcon->fsUnixInfo.Capability = 0;
3081 tcon->unix_ext = 0; /* Unix Extensions disabled */
f96637be 3082 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
c18c842b
SF		 3083 return;
3084 } else if (vol_info)
3085 tcon->unix_ext = 1; /* Unix Extensions supported */
3086
3087 if (tcon->unix_ext == 0) {
f96637be 3088 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
c18c842b
SF		 3089 return;
3090 }
50c2f753 3091
fb8c4b14 3092 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
8af18971 3093 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
f96637be 3094 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
8af18971
SF		 3095 /* check for reconnect case in which we do not
3096 want to change the mount behavior if we can avoid it */
fb8c4b14 3097 if (vol_info == NULL) {
50c2f753 3098 /* turn off POSIX ACL and PATHNAMES if not set
8af18971
SF		 3099 originally at mount time */
3100 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3101 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
11b6d645
IM		 3102 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3103 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
f96637be 3104 cifs_dbg(VFS, "POSIXPATH support change\n");
8af18971 3105 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
11b6d645 3106 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
f96637be
JP		 3107 cifs_dbg(VFS, "possible reconnect error\n");
3108 cifs_dbg(VFS, "server disabled POSIX path support\n");
11b6d645 3109 }
8af18971 3110 }
50c2f753 3111
6848b733 3112 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
f96637be 3113 cifs_dbg(VFS, "per-share encryption not supported yet\n");
6848b733 3114
8af18971 3115 cap &= CIFS_UNIX_CAP_MASK;
75865f8c 3116 if (vol_info && vol_info->no_psx_acl)
8af18971 3117 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
75865f8c 3118 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
f96637be 3119 cifs_dbg(FYI, "negotiated posix acl support\n");
2c6292ae
AV		 3120 if (cifs_sb)
3121 cifs_sb->mnt_cifs_flags |=
3122 CIFS_MOUNT_POSIXACL;
8af18971
SF		 3123 }
3124
75865f8c 3125 if (vol_info && vol_info->posix_paths == 0)
8af18971 3126 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
75865f8c 3127 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
f96637be 3128 cifs_dbg(FYI, "negotiate posix pathnames\n");
2c6292ae
AV		 3129 if (cifs_sb)
3130 cifs_sb->mnt_cifs_flags |=
8af18971
SF		 3131 CIFS_MOUNT_POSIX_PATHS;
3132 }
50c2f753 3133
f96637be 3134 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
8af18971 3135#ifdef CONFIG_CIFS_DEBUG2
75865f8c 3136 if (cap & CIFS_UNIX_FCNTL_CAP)
f96637be 3137 cifs_dbg(FYI, "FCNTL cap\n");
75865f8c 3138 if (cap & CIFS_UNIX_EXTATTR_CAP)
f96637be 3139 cifs_dbg(FYI, "EXTATTR cap\n");
75865f8c 3140 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
f96637be 3141 cifs_dbg(FYI, "POSIX path cap\n");
75865f8c 3142 if (cap & CIFS_UNIX_XATTR_CAP)
f96637be 3143 cifs_dbg(FYI, "XATTR cap\n");
75865f8c 3144 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
f96637be 3145 cifs_dbg(FYI, "POSIX ACL cap\n");
75865f8c 3146 if (cap & CIFS_UNIX_LARGE_READ_CAP)
f96637be 3147 cifs_dbg(FYI, "very large read cap\n");
75865f8c 3148 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
f96637be 3149 cifs_dbg(FYI, "very large write cap\n");
6848b733 3150 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
f96637be 3151 cifs_dbg(FYI, "transport encryption cap\n");
6848b733 3152 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
f96637be 3153 cifs_dbg(FYI, "mandatory transport encryption cap\n");
8af18971
SF		 3154#endif /* CIFS_DEBUG2 */
3155 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
442aa310 3156 if (vol_info == NULL) {
f96637be 3157 cifs_dbg(FYI, "resetting capabilities failed\n");
442aa310 3158 } else
f96637be 3159 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 3160
8af18971
SF		 3161 }
3162 }
3163}
3164
724d9f1c
PS		 3165void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3166 struct cifs_sb_info *cifs_sb)
b1c8d2b4 3167{
2de970ff
JL		 3168 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3169
2ced6f69
AV		 3170 spin_lock_init(&cifs_sb->tlink_tree_lock);
3171 cifs_sb->tlink_tree = RB_ROOT;
3172
25c7f41e 3173 /*
5eba8ab3
JL		 3174 * Temporarily set r/wsize for matching superblock. If we end up using
3175 * new sb then client will later negotiate it downward if needed.
25c7f41e 3176 */
5eba8ab3 3177 cifs_sb->rsize = pvolume_info->rsize;
25c7f41e
PS		 3178 cifs_sb->wsize = pvolume_info->wsize;
3179
3b795210
SF		 3180 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3181 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3182 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3183 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
f96637be
JP		 3184 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3185 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3b795210 3186
6d20e840 3187 cifs_sb->actimeo = pvolume_info->actimeo;
724d9f1c 3188 cifs_sb->local_nls = pvolume_info->local_nls;
6d20e840 3189
3b795210
SF		 3190 if (pvolume_info->noperm)
3191 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3192 if (pvolume_info->setuids)
3193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3194 if (pvolume_info->server_ino)
3195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3196 if (pvolume_info->remap)
3197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3198 if (pvolume_info->no_xattr)
3199 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3200 if (pvolume_info->sfu_emul)
3201 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3202 if (pvolume_info->nobrl)
3203 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
be652445 3204 if (pvolume_info->nostrictsync)
4717bed6 3205 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
13a6e42a
SF		 3206 if (pvolume_info->mand_lock)
3207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
d4ffff1f
PS		 3208 if (pvolume_info->rwpidforward)
3209 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3b795210
SF		 3210 if (pvolume_info->cifs_acl)
3211 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3c7c87fd 3212 if (pvolume_info->backupuid_specified) {
3d3ea8e6 3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3c7c87fd
SP		 3214 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3215 }
3216 if (pvolume_info->backupgid_specified) {
3d3ea8e6 3217 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3c7c87fd
SP		 3218 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3219 }
3b795210
SF		 3220 if (pvolume_info->override_uid)
3221 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3222 if (pvolume_info->override_gid)
3223 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3224 if (pvolume_info->dynperm)
3225 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
fa1df75d
SJ		 3226 if (pvolume_info->fsc)
3227 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
0eb8a132
JL		 3228 if (pvolume_info->multiuser)
3229 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3230 CIFS_MOUNT_NO_PERM);
d39454ff
PS		 3231 if (pvolume_info->strict_io)
3232 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3b795210 3233 if (pvolume_info->direct_io) {
f96637be 3234 cifs_dbg(FYI, "mounting share using direct i/o\n");
3b795210
SF		 3235 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3236 }
736a3320
SM		 3237 if (pvolume_info->mfsymlinks) {
3238 if (pvolume_info->sfu_emul) {
f96637be 3239 cifs_dbg(VFS, "mount option mfsymlinks ignored if sfu mount option is used\n");
736a3320
SM		 3240 } else {
3241 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3242 }
3243 }
3b795210
SF		 3244
3245 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
f96637be 3246 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
b1c8d2b4
JL		 3247}
3248
b9bce2e9
JL		 3249static void
3250cleanup_volume_info_contents(struct smb_vol *volume_info)
1bfe73c2 3251{
b946845a 3252 kfree(volume_info->username);
1bfe73c2 3253 kzfree(volume_info->password);
95c75454 3254 kfree(volume_info->UNC);
b946845a
SF		 3255 kfree(volume_info->domainname);
3256 kfree(volume_info->iocharset);
1bfe73c2 3257 kfree(volume_info->prepath);
b9bce2e9
JL		 3258}
3259
3260void
3261cifs_cleanup_volume_info(struct smb_vol *volume_info)
3262{
3263 if (!volume_info)
3264 return;
3265 cleanup_volume_info_contents(volume_info);
1bfe73c2 3266 kfree(volume_info);
1bfe73c2
IM		 3267}
3268
b9bce2e9 3269
2d6d589d 3270#ifdef CONFIG_CIFS_DFS_UPCALL
6d3ea7e4
SF		 3271/*
3272 * cifs_build_path_to_root returns full path to root when we do not have an
3273 * exiting connection (tcon)
3274 */
1bfe73c2 3275static char *
b2a0fa15 3276build_unc_path_to_root(const struct smb_vol *vol,
1bfe73c2
IM		 3277 const struct cifs_sb_info *cifs_sb)
3278{
b2a0fa15 3279 char *full_path, *pos;
839db3d1 3280 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
b2a0fa15 3281 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
1bfe73c2 3282
b2a0fa15 3283 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
1bfe73c2
IM		 3284 if (full_path == NULL)
3285 return ERR_PTR(-ENOMEM);
3286
b2a0fa15
JL		 3287 strncpy(full_path, vol->UNC, unc_len);
3288 pos = full_path + unc_len;
3289
3290 if (pplen) {
1fc29bac
JL		 3291 *pos = CIFS_DIR_SEP(cifs_sb);
3292 strncpy(pos + 1, vol->prepath, pplen);
b2a0fa15
JL		 3293 pos += pplen;
3294 }
3295
3296 *pos = '\0'; /* add trailing null */
f87d39d9 3297 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
f96637be 3298 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
1bfe73c2
IM		 3299 return full_path;
3300}
dd613945
SF		 3301
3302/*
3303 * Perform a dfs referral query for a share and (optionally) prefix
3304 *
046462ab
SF		 3305 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3306 * to a string containing updated options for the submount. Otherwise it
3307 * will be left untouched.
dd613945
SF		 3308 *
3309 * Returns the rc from get_dfs_path to the caller, which can be used to
3310 * determine whether there were referrals.
3311 */
3312static int
b669f33c 3313expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
dd613945 3314 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
046462ab 3315 int check_prefix)
dd613945
SF		 3316{
3317 int rc;
3318 unsigned int num_referrals = 0;
3319 struct dfs_info3_param *referrals = NULL;
3320 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3321
3322 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3323 if (IS_ERR(full_path))
3324 return PTR_ERR(full_path);
3325
3326 /* For DFS paths, skip the first '\' of the UNC */
3327 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3328
b669f33c 3329 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
dd613945
SF		 3330 &num_referrals, &referrals,
3331 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3332
3333 if (!rc && num_referrals > 0) {
3334 char *fake_devname = NULL;
3335
3336 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3337 full_path + 1, referrals,
3338 &fake_devname);
3339
3340 free_dfs_info_array(referrals, num_referrals);
046462ab 3341
dd613945
SF		 3342 if (IS_ERR(mdata)) {
3343 rc = PTR_ERR(mdata);
3344 mdata = NULL;
b9bce2e9
JL		 3345 } else {
3346 cleanup_volume_info_contents(volume_info);
b9bce2e9
JL		 3347 rc = cifs_setup_volume_info(volume_info, mdata,
3348 fake_devname);
dd613945 3349 }
b9bce2e9
JL		 3350 kfree(fake_devname);
3351 kfree(cifs_sb->mountdata);
046462ab 3352 cifs_sb->mountdata = mdata;
dd613945
SF		 3353 }
3354 kfree(full_path);
3355 return rc;
3356}
2d6d589d 3357#endif
1bfe73c2 3358
04db79b0
JL		 3359static int
3360cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3361 const char *devname)
1da177e4 3362{
724d9f1c 3363 int rc = 0;
1da177e4 3364
04db79b0
JL		 3365 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3366 return -EINVAL;
1da177e4 3367
7586b765 3368 if (volume_info->nullauth) {
f96637be 3369 cifs_dbg(FYI, "Anonymous login\n");
04febabc
JL		 3370 kfree(volume_info->username);
3371 volume_info->username = NULL;
7586b765 3372 } else if (volume_info->username) {
1da177e4 3373 /* BB fixme parse for domain name here */
f96637be 3374 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
1da177e4 3375 } else {
f96637be 3376 cifs_dbg(VFS, "No username specified\n");
50c2f753
SF		 3377 /* In userspace mount helper we can get user name from alternate
3378 locations such as env variables and files on disk */
04db79b0 3379 return -EINVAL;
1da177e4
LT		 3380 }
3381
1da177e4 3382 /* this is needed for ASCII cp to Unicode converts */
7586b765 3383 if (volume_info->iocharset == NULL) {
a5fc4ce0
JL		 3384 /* load_nls_default cannot return null */
3385 volume_info->local_nls = load_nls_default();
1da177e4 3386 } else {
a5fc4ce0
JL		 3387 volume_info->local_nls = load_nls(volume_info->iocharset);
3388 if (volume_info->local_nls == NULL) {
f96637be 3389 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
b6b38f70 3390 volume_info->iocharset);
04db79b0 3391 return -ELIBACC;
1da177e4
LT		 3392 }
3393 }
724d9f1c 3394
724d9f1c
PS		 3395 return rc;
3396}
3397
04db79b0
JL		 3398struct smb_vol *
3399cifs_get_volume_info(char *mount_data, const char *devname)
3400{
3401 int rc;
3402 struct smb_vol *volume_info;
3403
6ee9542a 3404 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
04db79b0
JL		 3405 if (!volume_info)
3406 return ERR_PTR(-ENOMEM);
3407
3408 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3409 if (rc) {
3410 cifs_cleanup_volume_info(volume_info);
3411 volume_info = ERR_PTR(rc);
3412 }
3413
3414 return volume_info;
3415}
3416
724d9f1c 3417int
2c6292ae 3418cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
724d9f1c 3419{
1daaae8f 3420 int rc;
6d5786a3 3421 unsigned int xid;
af4281dc 3422 struct cifs_ses *ses;
96daf2b0 3423 struct cifs_tcon *tcon;
af4281dc 3424 struct TCP_Server_Info *server;
724d9f1c
PS		 3425 char *full_path;
3426 struct tcon_link *tlink;
3427#ifdef CONFIG_CIFS_DFS_UPCALL
3428 int referral_walks_count = 0;
20547490 3429#endif
dd854466
AV		 3430
3431 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3432 if (rc)
3433 return rc;
3434
20547490 3435#ifdef CONFIG_CIFS_DFS_UPCALL
724d9f1c
PS		 3436try_mount_again:
3437 /* cleanup activities if we're chasing a referral */
3438 if (referral_walks_count) {
3439 if (tcon)
3440 cifs_put_tcon(tcon);
af4281dc
PS		 3441 else if (ses)
3442 cifs_put_smb_ses(ses);
724d9f1c 3443
6d5786a3 3444 free_xid(xid);
724d9f1c
PS		 3445 }
3446#endif
1daaae8f 3447 rc = 0;
724d9f1c 3448 tcon = NULL;
af4281dc
PS		 3449 ses = NULL;
3450 server = NULL;
724d9f1c
PS		 3451 full_path = NULL;
3452 tlink = NULL;
3453
6d5786a3 3454 xid = get_xid();
1da177e4 3455
63c038c2 3456 /* get a reference to a tcp session */
af4281dc
PS		 3457 server = cifs_get_tcp_session(volume_info);
3458 if (IS_ERR(server)) {
3459 rc = PTR_ERR(server);
dd854466 3460 bdi_destroy(&cifs_sb->bdi);
63c038c2 3461 goto out;
1da177e4
LT		 3462 }
3463
36988c76 3464 /* get a reference to a SMB session */
af4281dc
PS		 3465 ses = cifs_get_smb_ses(server, volume_info);
3466 if (IS_ERR(ses)) {
3467 rc = PTR_ERR(ses);
3468 ses = NULL;
36988c76 3469 goto mount_fail_check;
1da177e4 3470 }
50c2f753 3471
d00c28de 3472 /* search for existing tcon to this server share */
af4281dc 3473 tcon = cifs_get_tcon(ses, volume_info);
d00c28de
JL		 3474 if (IS_ERR(tcon)) {
3475 rc = PTR_ERR(tcon);
3476 tcon = NULL;
1bfe73c2 3477 goto remote_path_check;
d00c28de 3478 }
1bfe73c2 3479
d82c2df5 3480 /* tell server which Unix caps we support */
29e20f9c 3481 if (cap_unix(tcon->ses)) {
d82c2df5
SF		 3482 /* reset of caps checks mount to see if unix extensions
3483 disabled for just this mount */
2c6292ae 3484 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
6848b733
SF		 3485 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3486 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3487 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3488 rc = -EACCES;
3489 goto mount_fail_check;
3490 }
3491 } else
d82c2df5 3492 tcon->unix_ext = 0; /* server does not support them */
c18c842b 3493
af4281dc
PS		 3494 /* do not care if a following call succeed - informational */
3495 if (!tcon->ipc && server->ops->qfs_tcon)
3496 server->ops->qfs_tcon(xid, tcon);
6848b733 3497
24985c53
PS		 3498 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3499 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
f7910cbd 3500
66bfaadc 3501 /* tune readahead according to rsize */
8f71465c 3502 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
f7910cbd 3503
1bfe73c2 3504remote_path_check:
c1508ca2
SF		 3505#ifdef CONFIG_CIFS_DFS_UPCALL
3506 /*
3507 * Perform an unconditional check for whether there are DFS
3508 * referrals for this path without prefix, to provide support
3509 * for DFS referrals from w2k8 servers which don't seem to respond
3510 * with PATH_NOT_COVERED to requests that include the prefix.
3511 * Chase the referral if found, otherwise continue normally.
3512 */
3513 if (referral_walks_count == 0) {
af4281dc
PS		 3514 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3515 false);
c1508ca2
SF		 3516 if (!refrc) {
3517 referral_walks_count++;
3518 goto try_mount_again;
3519 }
3520 }
3521#endif
3522
f87d39d9 3523 /* check if a whole path is not remote */
70945643 3524 if (!rc && tcon) {
68889f26
PS		 3525 if (!server->ops->is_path_accessible) {
3526 rc = -ENOSYS;
3527 goto mount_fail_check;
3528 }
6d3ea7e4
SF		 3529 /*
3530 * cifs_build_path_to_root works only when we have a valid tcon
3531 */
3532 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
e4cce94c
IM		 3533 if (full_path == NULL) {
3534 rc = -ENOMEM;
3535 goto mount_fail_check;
3536 }
68889f26
PS		 3537 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3538 full_path);
03ceace5 3539 if (rc != 0 && rc != -EREMOTE) {
e4cce94c
IM		 3540 kfree(full_path);
3541 goto mount_fail_check;
3542 }
3543 kfree(full_path);
3544 }
3545
1bfe73c2
IM		 3546 /* get referral if needed */
3547 if (rc == -EREMOTE) {
d036f50f 3548#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8
IM		 3549 if (referral_walks_count > MAX_NESTED_LINKS) {
3550 /*
3551 * BB: when we implement proper loop detection,
3552 * we will remove this check. But now we need it
3553 * to prevent an indefinite loop if 'DFS tree' is
3554 * misconfigured (i.e. has loops).
3555 */
3556 rc = -ELOOP;
3557 goto mount_fail_check;
3558 }
1bfe73c2 3559
af4281dc 3560 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
7b91e266 3561
dd613945 3562 if (!rc) {
5c2503a8 3563 referral_walks_count++;
1bfe73c2
IM		 3564 goto try_mount_again;
3565 }
dd613945 3566 goto mount_fail_check;
d036f50f
SF		 3567#else /* No DFS support, return error on mount */
3568 rc = -EOPNOTSUPP;
3569#endif
1bfe73c2
IM		 3570 }
3571
9d002df4
JL		 3572 if (rc)
3573 goto mount_fail_check;
3574
3575 /* now, hang the tcon off of the superblock */
3576 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3577 if (tlink == NULL) {
3578 rc = -ENOMEM;
3579 goto mount_fail_check;
3580 }
3581
af4281dc 3582 tlink->tl_uid = ses->linux_uid;
9d002df4
JL		 3583 tlink->tl_tcon = tcon;
3584 tlink->tl_time = jiffies;
3585 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3586 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3587
b647c35f 3588 cifs_sb->master_tlink = tlink;
9d002df4 3589 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3590 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
9d002df4 3591 spin_unlock(&cifs_sb->tlink_tree_lock);
413e661c 3592
da472fc8 3593 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 3594 TLINK_IDLE_EXPIRE);
3595
1bfe73c2
IM		 3596mount_fail_check:
3597 /* on error free sesinfo and tcon struct if needed */
3598 if (rc) {
1bfe73c2 3599 /* If find_unc succeeded then rc == 0 so we can not end */
25985edc 3600 /* up accidentally freeing someone elses tcon struct */
1bfe73c2
IM		 3601 if (tcon)
3602 cifs_put_tcon(tcon);
af4281dc
PS		 3603 else if (ses)
3604 cifs_put_smb_ses(ses);
1bfe73c2 3605 else
af4281dc 3606 cifs_put_tcp_session(server);
dd854466 3607 bdi_destroy(&cifs_sb->bdi);
1bfe73c2
IM		 3608 }
3609
70fe7dc0 3610out:
6d5786a3 3611 free_xid(xid);
1da177e4
LT		 3612 return rc;
3613}
3614
8d1bca32
JL		 3615/*
3616 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3617 * pointer may be NULL.
3618 */
1da177e4 3619int
2e6e02ab 3620CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
96daf2b0 3621 const char *tree, struct cifs_tcon *tcon,
1da177e4
LT		 3622 const struct nls_table *nls_codepage)
3623{
3624 struct smb_hdr *smb_buffer;
3625 struct smb_hdr *smb_buffer_response;
3626 TCONX_REQ *pSMB;
3627 TCONX_RSP *pSMBr;
3628 unsigned char *bcc_ptr;
3629 int rc = 0;
690c522f
JL		 3630 int length;
3631 __u16 bytes_left, count;
1da177e4
LT		 3632
3633 if (ses == NULL)
3634 return -EIO;
3635
3636 smb_buffer = cifs_buf_get();
ca43e3be 3637 if (smb_buffer == NULL)
1da177e4 3638 return -ENOMEM;
ca43e3be 3639
1da177e4
LT		 3640 smb_buffer_response = smb_buffer;
3641
3642 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3643 NULL /*no tid */ , 4 /*wct */ );
1982c344 3644
88257360 3645 smb_buffer->Mid = get_next_mid(ses->server);
1da177e4
LT		 3646 smb_buffer->Uid = ses->Suid;
3647 pSMB = (TCONX_REQ *) smb_buffer;
3648 pSMBr = (TCONX_RSP *) smb_buffer_response;
3649
3650 pSMB->AndXCommand = 0xFF;
3651 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
1da177e4 3652 bcc_ptr = &pSMB->Password[0];
8d1bca32 3653 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
eeac8047 3654 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
7c7b25bc 3655 *bcc_ptr = 0; /* password is null byte */
eeac8047 3656 bcc_ptr++; /* skip password */
7c7b25bc 3657 /* already aligned so no need to do it below */
eeac8047 3658 } else {
540b2e37 3659 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
eeac8047
SF		 3660 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3661 specified as required (when that support is added to
3662 the vfs in the future) as only NTLM or the much
7c7b25bc 3663 weaker LANMAN (which we do not send by default) is accepted
eeac8047
SF		 3664 by Samba (not sure whether other servers allow
3665 NTLMv2 password here) */
7c7b25bc 3666#ifdef CONFIG_CIFS_WEAK_PW_HASH
04912d6a 3667 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
00e485b0 3668 (ses->server->secType == LANMAN))
d3ba50b1 3669 calc_lanman_hash(tcon->password, ses->server->cryptkey,
96daf2b0 3670 ses->server->sec_mode &
4e53a3fb
JL		 3671 SECMODE_PW_ENCRYPT ? true : false,
3672 bcc_ptr);
7c7b25bc
SF		 3673 else
3674#endif /* CIFS_WEAK_PW_HASH */
ee2c9258 3675 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
9ef5992e 3676 bcc_ptr, nls_codepage);
eeac8047 3677
540b2e37 3678 bcc_ptr += CIFS_AUTH_RESP_SIZE;
fb8c4b14 3679 if (ses->capabilities & CAP_UNICODE) {
7c7b25bc
SF		 3680 /* must align unicode strings */
3681 *bcc_ptr = 0; /* null byte password */
3682 bcc_ptr++;
3683 }
eeac8047 3684 }
1da177e4 3685
96daf2b0 3686 if (ses->server->sec_mode &
a878fb22 3687 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1da177e4
LT		 3688 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3689
3690 if (ses->capabilities & CAP_STATUS32) {
3691 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3692 }
3693 if (ses->capabilities & CAP_DFS) {
3694 smb_buffer->Flags2 |= SMBFLG2_DFS;
3695 }
3696 if (ses->capabilities & CAP_UNICODE) {
3697 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3698 length =
acbbb76a 3699 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
50c2f753 3700 6 /* max utf8 char length in bytes */ *
a878fb22
SF		 3701 (/* server len*/ + 256 /* share len */), nls_codepage);
3702 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
1da177e4
LT		 3703 bcc_ptr += 2; /* skip trailing null */
3704 } else { /* ASCII */
1da177e4
LT		 3705 strcpy(bcc_ptr, tree);
3706 bcc_ptr += strlen(tree) + 1;
3707 }
3708 strcpy(bcc_ptr, "?????");
3709 bcc_ptr += strlen("?????");
3710 bcc_ptr += 1;
3711 count = bcc_ptr - &pSMB->Password[0];
be8e3b00
SF		 3712 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3713 pSMB->hdr.smb_buf_length) + count);
1da177e4
LT		 3714 pSMB->ByteCount = cpu_to_le16(count);
3715
133672ef 3716 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
7749981e 3717 0);
1da177e4 3718
1da177e4
LT		 3719 /* above now done in SendReceive */
3720 if ((rc == 0) && (tcon != NULL)) {
0e0d2cf3
SF		 3721 bool is_unicode;
3722
1da177e4 3723 tcon->tidStatus = CifsGood;
3b795210 3724 tcon->need_reconnect = false;
1da177e4
LT		 3725 tcon->tid = smb_buffer_response->Tid;
3726 bcc_ptr = pByteArea(smb_buffer_response);
690c522f 3727 bytes_left = get_bcc(smb_buffer_response);
cc20c031 3728 length = strnlen(bcc_ptr, bytes_left - 2);
0e0d2cf3
SF		 3729 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3730 is_unicode = true;
3731 else
3732 is_unicode = false;
3733
cc20c031 3734
50c2f753 3735 /* skip service field (NB: this field is always ASCII) */
7f8ed420
SF		 3736 if (length == 3) {
3737 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3738 (bcc_ptr[2] == 'C')) {
f96637be 3739 cifs_dbg(FYI, "IPC connection\n");
7f8ed420
SF		 3740 tcon->ipc = 1;
3741 }
3742 } else if (length == 2) {
3743 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3744 /* the most common case */
f96637be 3745 cifs_dbg(FYI, "disk share connection\n");
7f8ed420
SF		 3746 }
3747 }
50c2f753 3748 bcc_ptr += length + 1;
cc20c031 3749 bytes_left -= (length + 1);
1da177e4 3750 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
cc20c031
JL		 3751
3752 /* mostly informational -- no need to fail on error here */
90a98b2f 3753 kfree(tcon->nativeFileSystem);
acbbb76a 3754 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
0e0d2cf3 3755 bytes_left, is_unicode,
cc20c031
JL		 3756 nls_codepage);
3757
f96637be 3758 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
cc20c031 3759
fb8c4b14 3760 if ((smb_buffer_response->WordCount == 3) ||
1a4e15a0
SF		 3761 (smb_buffer_response->WordCount == 7))
3762 /* field is in same location */
3979877e
SF		 3763 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3764 else
3765 tcon->Flags = 0;
f96637be 3766 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
1da177e4 3767 } else if ((rc == 0) && tcon == NULL) {
50c2f753 3768 /* all we need to save for IPC$ connection */
1da177e4
LT		 3769 ses->ipc_tid = smb_buffer_response->Tid;
3770 }
3771
a8a11d39 3772 cifs_buf_release(smb_buffer);
1da177e4
LT		 3773 return rc;
3774}
3775
2a9b9951
AV		 3776void
3777cifs_umount(struct cifs_sb_info *cifs_sb)
1da177e4 3778{
b647c35f
JL		 3779 struct rb_root *root = &cifs_sb->tlink_tree;
3780 struct rb_node *node;
3781 struct tcon_link *tlink;
9d002df4 3782
2de970ff
JL		 3783 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3784
b647c35f
JL		 3785 spin_lock(&cifs_sb->tlink_tree_lock);
3786 while ((node = rb_first(root))) {
3787 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3788 cifs_get_tlink(tlink);
3789 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3790 rb_erase(node, root);
1da177e4 3791
b647c35f
JL		 3792 spin_unlock(&cifs_sb->tlink_tree_lock);
3793 cifs_put_tlink(tlink);
3794 spin_lock(&cifs_sb->tlink_tree_lock);
3795 }
3796 spin_unlock(&cifs_sb->tlink_tree_lock);
50c2f753 3797
dd854466 3798 bdi_destroy(&cifs_sb->bdi);
d757d71b
AV		 3799 kfree(cifs_sb->mountdata);
3800 unload_nls(cifs_sb->local_nls);
3801 kfree(cifs_sb);
50c2f753 3802}
1da177e4 3803
286170aa
PS		 3804int
3805cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
1da177e4
LT		 3806{
3807 int rc = 0;
198b5682 3808 struct TCP_Server_Info *server = ses->server;
1da177e4 3809
286170aa
PS		 3810 if (!server->ops->need_neg || !server->ops->negotiate)
3811 return -ENOSYS;
3812
198b5682 3813 /* only send once per connect */
286170aa 3814 if (!server->ops->need_neg(server))
198b5682
JL		 3815 return 0;
3816
45275789 3817 set_credits(server, 1);
286170aa
PS		 3818
3819 rc = server->ops->negotiate(xid, ses);
198b5682
JL		 3820 if (rc == 0) {
3821 spin_lock(&GlobalMid_Lock);
7fdbaa1b 3822 if (server->tcpStatus == CifsNeedNegotiate)
198b5682
JL		 3823 server->tcpStatus = CifsGood;
3824 else
3825 rc = -EHOSTDOWN;
3826 spin_unlock(&GlobalMid_Lock);
198b5682
JL		 3827 }
3828
3829 return rc;
3830}
3831
58c45c58
PS		 3832int
3833cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3834 struct nls_table *nls_info)
198b5682 3835{
58c45c58 3836 int rc = -ENOSYS;
198b5682 3837 struct TCP_Server_Info *server = ses->server;
26b994fa 3838
198b5682 3839 ses->capabilities = server->capabilities;
26b994fa 3840 if (linuxExtEnabled == 0)
29e20f9c 3841 ses->capabilities &= (~server->vals->cap_unix);
20418acd 3842
f96637be 3843 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
96daf2b0 3844 server->sec_mode, server->capabilities, server->timeAdj);
cb7691b6 3845
58c45c58
PS		 3846 if (server->ops->sess_setup)
3847 rc = server->ops->sess_setup(xid, ses, nls_info);
3848
26b994fa 3849 if (rc) {
f96637be 3850 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
26b994fa 3851 } else {
b13ce4bb 3852 mutex_lock(&server->srv_mutex);
5d0d2882 3853 if (!server->session_estab) {
21e73393 3854 server->session_key.response = ses->auth_key.response;
5d0d2882 3855 server->session_key.len = ses->auth_key.len;
21e73393
SP		 3856 server->sequence_number = 0x2;
3857 server->session_estab = true;
3858 ses->auth_key.response = NULL;
5d0d2882
SP		 3859 }
3860 mutex_unlock(&server->srv_mutex);
3861
f96637be 3862 cifs_dbg(FYI, "CIFS Session Established successfully\n");
20418acd 3863 spin_lock(&GlobalMid_Lock);
198b5682
JL		 3864 ses->status = CifsGood;
3865 ses->need_reconnect = false;
20418acd 3866 spin_unlock(&GlobalMid_Lock);
1da177e4 3867 }
26b994fa 3868
21e73393
SP		 3869 kfree(ses->auth_key.response);
3870 ses->auth_key.response = NULL;
3871 ses->auth_key.len = 0;
d3686d54
SP		 3872 kfree(ses->ntlmssp);
3873 ses->ntlmssp = NULL;
21e73393 3874
1da177e4
LT		 3875 return rc;
3876}
3877
8a8798a5
JL		 3878static int
3879cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3880{
3881 switch (ses->server->secType) {
3882 case Kerberos:
3883 vol->secFlg = CIFSSEC_MUST_KRB5;
3884 return 0;
3885 case NTLMv2:
3886 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3887 break;
3888 case NTLM:
3889 vol->secFlg = CIFSSEC_MUST_NTLM;
3890 break;
3891 case RawNTLMSSP:
3892 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3893 break;
3894 case LANMAN:
3895 vol->secFlg = CIFSSEC_MUST_LANMAN;
3896 break;
3897 }
3898
3899 return cifs_set_cifscreds(vol, ses);
3900}
3901
96daf2b0 3902static struct cifs_tcon *
6d4a0832 3903cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
9d002df4 3904{
8a8798a5 3905 int rc;
96daf2b0
SF		 3906 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3907 struct cifs_ses *ses;
3908 struct cifs_tcon *tcon = NULL;
9d002df4 3909 struct smb_vol *vol_info;
9d002df4
JL		 3910
3911 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
803ab977
DC		 3912 if (vol_info == NULL)
3913 return ERR_PTR(-ENOMEM);
9d002df4 3914
9d002df4
JL		 3915 vol_info->local_nls = cifs_sb->local_nls;
3916 vol_info->linux_uid = fsuid;
3917 vol_info->cred_uid = fsuid;
3918 vol_info->UNC = master_tcon->treeName;
3919 vol_info->retry = master_tcon->retry;
3920 vol_info->nocase = master_tcon->nocase;
3921 vol_info->local_lease = master_tcon->local_lease;
3922 vol_info->no_linux_ext = !master_tcon->unix_ext;
28e11bd8
JL		 3923 vol_info->sectype = master_tcon->ses->sectype;
3924 vol_info->sign = master_tcon->ses->sign;
9d002df4 3925
8a8798a5
JL		 3926 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3927 if (rc) {
3928 tcon = ERR_PTR(rc);
3929 goto out;
3930 }
9d002df4
JL		 3931
3932 /* get a reference for the same TCP session */
3f9bcca7 3933 spin_lock(&cifs_tcp_ses_lock);
9d002df4 3934 ++master_tcon->ses->server->srv_count;
3f9bcca7 3935 spin_unlock(&cifs_tcp_ses_lock);
9d002df4
JL		 3936
3937 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3938 if (IS_ERR(ses)) {
96daf2b0 3939 tcon = (struct cifs_tcon *)ses;
9d002df4
JL		 3940 cifs_put_tcp_session(master_tcon->ses->server);
3941 goto out;
3942 }
3943
3944 tcon = cifs_get_tcon(ses, vol_info);
3945 if (IS_ERR(tcon)) {
3946 cifs_put_smb_ses(ses);
3947 goto out;
3948 }
3949
29e20f9c 3950 if (cap_unix(ses))
9d002df4
JL		 3951 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3952out:
8a8798a5
JL		 3953 kfree(vol_info->username);
3954 kfree(vol_info->password);
9d002df4
JL		 3955 kfree(vol_info);
3956
3957 return tcon;
3958}
3959
96daf2b0 3960struct cifs_tcon *
9d002df4
JL		 3961cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3962{
3963 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3964}
3965
3966static int
3967cifs_sb_tcon_pending_wait(void *unused)
3968{
3969 schedule();
3970 return signal_pending(current) ? -ERESTARTSYS : 0;
3971}
3972
b647c35f
JL		 3973/* find and return a tlink with given uid */
3974static struct tcon_link *
6d4a0832 3975tlink_rb_search(struct rb_root *root, kuid_t uid)
b647c35f
JL		 3976{
3977 struct rb_node *node = root->rb_node;
3978 struct tcon_link *tlink;
3979
3980 while (node) {
3981 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3982
6d4a0832 3983 if (uid_gt(tlink->tl_uid, uid))
b647c35f 3984 node = node->rb_left;
6d4a0832 3985 else if (uid_lt(tlink->tl_uid, uid))
b647c35f
JL		 3986 node = node->rb_right;
3987 else
3988 return tlink;
3989 }
3990 return NULL;
3991}
3992
3993/* insert a tcon_link into the tree */
3994static void
3995tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3996{
3997 struct rb_node **new = &(root->rb_node), *parent = NULL;
3998 struct tcon_link *tlink;
3999
4000 while (*new) {
4001 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4002 parent = *new;
4003
6d4a0832 4004 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
b647c35f
JL		 4005 new = &((*new)->rb_left);
4006 else
4007 new = &((*new)->rb_right);
4008 }
4009
4010 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4011 rb_insert_color(&new_tlink->tl_rbnode, root);
4012}
4013
9d002df4
JL		 4014/*
4015 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4016 * current task.
4017 *
4018 * If the superblock doesn't refer to a multiuser mount, then just return
4019 * the master tcon for the mount.
4020 *
6ef933a3 4021 * First, search the rbtree for an existing tcon for this fsuid. If one
9d002df4
JL		 4022 * exists, then check to see if it's pending construction. If it is then wait
4023 * for construction to complete. Once it's no longer pending, check to see if
4024 * it failed and either return an error or retry construction, depending on
4025 * the timeout.
4026 *
4027 * If one doesn't exist then insert a new tcon_link struct into the tree and
4028 * try to construct a new one.
4029 */
4030struct tcon_link *
4031cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4032{
4033 int ret;
6d4a0832 4034 kuid_t fsuid = current_fsuid();
9d002df4
JL		 4035 struct tcon_link *tlink, *newtlink;
4036
4037 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4038 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4039
4040 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 4041 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4042 if (tlink)
4043 cifs_get_tlink(tlink);
4044 spin_unlock(&cifs_sb->tlink_tree_lock);
4045
4046 if (tlink == NULL) {
4047 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4048 if (newtlink == NULL)
4049 return ERR_PTR(-ENOMEM);
b647c35f 4050 newtlink->tl_uid = fsuid;
9d002df4
JL		 4051 newtlink->tl_tcon = ERR_PTR(-EACCES);
4052 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4053 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4054 cifs_get_tlink(newtlink);
4055
9d002df4
JL		 4056 spin_lock(&cifs_sb->tlink_tree_lock);
4057 /* was one inserted after previous search? */
b647c35f 4058 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 4059 if (tlink) {
4060 cifs_get_tlink(tlink);
4061 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4062 kfree(newtlink);
4063 goto wait_for_construction;
4064 }
9d002df4 4065 tlink = newtlink;
b647c35f
JL		 4066 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4067 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 4068 } else {
4069wait_for_construction:
4070 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4071 cifs_sb_tcon_pending_wait,
4072 TASK_INTERRUPTIBLE);
4073 if (ret) {
4074 cifs_put_tlink(tlink);
4075 return ERR_PTR(ret);
4076 }
4077
4078 /* if it's good, return it */
4079 if (!IS_ERR(tlink->tl_tcon))
4080 return tlink;
4081
4082 /* return error if we tried this already recently */
4083 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4084 cifs_put_tlink(tlink);
4085 return ERR_PTR(-EACCES);
4086 }
4087
4088 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4089 goto wait_for_construction;
4090 }
4091
4092 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4093 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4094 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4095
4096 if (IS_ERR(tlink->tl_tcon)) {
4097 cifs_put_tlink(tlink);
4098 return ERR_PTR(-EACCES);
4099 }
4100
4101 return tlink;
4102}
2de970ff
JL		 4103
4104/*
4105 * periodic workqueue job that scans tcon_tree for a superblock and closes
4106 * out tcons.
4107 */
4108static void
4109cifs_prune_tlinks(struct work_struct *work)
4110{
4111 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4112 prune_tlinks.work);
b647c35f
JL		 4113 struct rb_root *root = &cifs_sb->tlink_tree;
4114 struct rb_node *node = rb_first(root);
4115 struct rb_node *tmp;
4116 struct tcon_link *tlink;
2de970ff 4117
b647c35f
JL		 4118 /*
4119 * Because we drop the spinlock in the loop in order to put the tlink
4120 * it's not guarded against removal of links from the tree. The only
4121 * places that remove entries from the tree are this function and
4122 * umounts. Because this function is non-reentrant and is canceled
4123 * before umount can proceed, this is safe.
4124 */
4125 spin_lock(&cifs_sb->tlink_tree_lock);
4126 node = rb_first(root);
4127 while (node != NULL) {
4128 tmp = node;
4129 node = rb_next(tmp);
4130 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4131
4132 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4133 atomic_read(&tlink->tl_count) != 0 ||
4134 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4135 continue;
2de970ff 4136
b647c35f
JL		 4137 cifs_get_tlink(tlink);
4138 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4139 rb_erase(tmp, root);
4140
4141 spin_unlock(&cifs_sb->tlink_tree_lock);
4142 cifs_put_tlink(tlink);
4143 spin_lock(&cifs_sb->tlink_tree_lock);
4144 }
4145 spin_unlock(&cifs_sb->tlink_tree_lock);
2de970ff 4146
da472fc8 4147 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2de970ff
JL		 4148 TLINK_IDLE_EXPIRE);
4149}
Linux kernel - Deliverables
This page took 0.847863 seconds and 5 git commands to generate.