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