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