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