blob: 4fbd92d2e113e69d5e3105235a215a52b2e756e7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve French1080ef72011-02-24 18:07:19 +00004 * Copyright (C) International Business Machines Corp., 2002,2011
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090026#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070031#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070032#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000033#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070034#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040036#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/uaccess.h>
38#include <asm/processor.h>
Jeff Layton50b64e32009-06-02 06:55:20 -040039#include <linux/inet.h>
Paul Gortmaker143cb492011-07-01 14:23:34 -040040#include <linux/module.h>
Jeff Layton8a8798a2012-01-17 16:09:15 -050041#include <keys/user-type.h>
Steve French0e2beda2009-01-30 21:24:41 +000042#include <net/ipv6.h>
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040043#include <linux/parser.h>
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#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"
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +053054#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56#define CIFS_PORT 445
57#define RFC1001_PORT 139
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059extern mempool_t *cifs_req_poolp;
60
Jeff Layton2de970f2010-10-06 19:51:12 -040061/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -040062#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -040063#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -040064
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040065enum {
66
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
Jeff Layton72bd4812012-10-03 16:02:36 -040070 Opt_forcegid, Opt_noforcegid,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040071 Opt_noblocksend, Opt_noautotune,
72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
Steve French2baa2682014-09-27 02:19:01 -050073 Opt_mapposix, Opt_nomapposix,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040074 Opt_mapchars, Opt_nomapchars, Opt_sfu,
75 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
76 Opt_noposixpaths, Opt_nounix,
77 Opt_nocase,
78 Opt_brl, Opt_nobrl,
79 Opt_forcemandatorylock, Opt_setuids,
80 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
81 Opt_nohard, Opt_nosoft,
82 Opt_nointr, Opt_intr,
83 Opt_nostrictsync, Opt_strictsync,
84 Opt_serverino, Opt_noserverino,
85 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
86 Opt_acl, Opt_noacl, Opt_locallease,
Jeff Layton1b359202012-09-19 15:20:27 -070087 Opt_sign, Opt_seal, Opt_noac,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040088 Opt_fsc, Opt_mfsymlinks,
Jeff Laytona0b3df52013-05-24 07:40:59 -040089 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
Steve Frenchb2a30772015-09-29 21:49:28 -050090 Opt_persistent, Opt_nopersistent,
Steve French592fafe2015-11-03 10:08:53 -060091 Opt_resilient, Opt_noresilient,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040092
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,
Steve Frenchadfeb3e2015-12-18 12:31:36 -060098 Opt_echo_interval,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040099
100 /* Mount options which take string value */
101 Opt_user, Opt_pass, Opt_ip,
Jeff Layton73a999f2013-03-22 08:42:57 -0400102 Opt_domain, Opt_srcaddr, Opt_iocharset,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400103 Opt_netbiosname, Opt_servern,
Jeff Layton23db65f2012-05-15 12:20:51 -0400104 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400105
106 /* Mount options to be ignored */
107 Opt_ignore,
108
109 /* Options which could be blank */
110 Opt_blank_pass,
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100111 Opt_blank_user,
112 Opt_blank_ip,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400113
114 Opt_err
115};
116
117static const match_table_t cifs_mount_option_tokens = {
118
119 { Opt_user_xattr, "user_xattr" },
120 { Opt_nouser_xattr, "nouser_xattr" },
121 { Opt_forceuid, "forceuid" },
122 { Opt_noforceuid, "noforceuid" },
Jeff Layton72bd4812012-10-03 16:02:36 -0400123 { Opt_forcegid, "forcegid" },
124 { Opt_noforcegid, "noforcegid" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400125 { Opt_noblocksend, "noblocksend" },
126 { Opt_noautotune, "noautotune" },
127 { Opt_hard, "hard" },
128 { Opt_soft, "soft" },
129 { Opt_perm, "perm" },
130 { Opt_noperm, "noperm" },
Steve French2baa2682014-09-27 02:19:01 -0500131 { Opt_mapchars, "mapchars" }, /* SFU style */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400132 { Opt_nomapchars, "nomapchars" },
Steve French2baa2682014-09-27 02:19:01 -0500133 { Opt_mapposix, "mapposix" }, /* SFM style */
134 { Opt_nomapposix, "nomapposix" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400135 { Opt_sfu, "sfu" },
136 { Opt_nosfu, "nosfu" },
137 { Opt_nodfs, "nodfs" },
138 { Opt_posixpaths, "posixpaths" },
139 { Opt_noposixpaths, "noposixpaths" },
140 { Opt_nounix, "nounix" },
141 { Opt_nounix, "nolinux" },
142 { Opt_nocase, "nocase" },
143 { Opt_nocase, "ignorecase" },
144 { Opt_brl, "brl" },
145 { Opt_nobrl, "nobrl" },
146 { Opt_nobrl, "nolock" },
147 { Opt_forcemandatorylock, "forcemandatorylock" },
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +0400148 { Opt_forcemandatorylock, "forcemand" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400149 { Opt_setuids, "setuids" },
150 { Opt_nosetuids, "nosetuids" },
151 { Opt_dynperm, "dynperm" },
152 { Opt_nodynperm, "nodynperm" },
153 { Opt_nohard, "nohard" },
154 { Opt_nosoft, "nosoft" },
155 { Opt_nointr, "nointr" },
156 { Opt_intr, "intr" },
157 { Opt_nostrictsync, "nostrictsync" },
158 { Opt_strictsync, "strictsync" },
159 { Opt_serverino, "serverino" },
160 { Opt_noserverino, "noserverino" },
161 { Opt_rwpidforward, "rwpidforward" },
162 { Opt_cifsacl, "cifsacl" },
163 { Opt_nocifsacl, "nocifsacl" },
164 { Opt_acl, "acl" },
165 { Opt_noacl, "noacl" },
166 { Opt_locallease, "locallease" },
167 { Opt_sign, "sign" },
168 { Opt_seal, "seal" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400169 { Opt_noac, "noac" },
170 { Opt_fsc, "fsc" },
171 { Opt_mfsymlinks, "mfsymlinks" },
172 { Opt_multiuser, "multiuser" },
Jeff Laytond8162552012-03-23 14:40:56 -0400173 { Opt_sloppy, "sloppy" },
Jeff Laytona0b3df52013-05-24 07:40:59 -0400174 { Opt_nosharesock, "nosharesock" },
Steve Frenchb2a30772015-09-29 21:49:28 -0500175 { Opt_persistent, "persistenthandles"},
176 { Opt_nopersistent, "nopersistenthandles"},
Steve French592fafe2015-11-03 10:08:53 -0600177 { Opt_resilient, "resilienthandles"},
178 { Opt_noresilient, "noresilienthandles"},
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400179
180 { Opt_backupuid, "backupuid=%s" },
181 { Opt_backupgid, "backupgid=%s" },
182 { Opt_uid, "uid=%s" },
183 { Opt_cruid, "cruid=%s" },
184 { Opt_gid, "gid=%s" },
185 { Opt_file_mode, "file_mode=%s" },
186 { Opt_dirmode, "dirmode=%s" },
187 { Opt_dirmode, "dir_mode=%s" },
188 { Opt_port, "port=%s" },
189 { Opt_rsize, "rsize=%s" },
190 { Opt_wsize, "wsize=%s" },
191 { Opt_actimeo, "actimeo=%s" },
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600192 { Opt_echo_interval, "echo_interval=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400193
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100194 { Opt_blank_user, "user=" },
195 { Opt_blank_user, "username=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400196 { Opt_user, "user=%s" },
197 { Opt_user, "username=%s" },
198 { Opt_blank_pass, "pass=" },
Jesper Nilsson3c15b4c2012-11-29 17:31:16 +0100199 { Opt_blank_pass, "password=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400200 { Opt_pass, "pass=%s" },
201 { Opt_pass, "password=%s" },
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100202 { Opt_blank_ip, "ip=" },
203 { Opt_blank_ip, "addr=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400204 { Opt_ip, "ip=%s" },
205 { Opt_ip, "addr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400206 { Opt_ignore, "unc=%s" },
207 { Opt_ignore, "target=%s" },
208 { Opt_ignore, "path=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400209 { Opt_domain, "dom=%s" },
210 { Opt_domain, "domain=%s" },
211 { Opt_domain, "workgroup=%s" },
212 { Opt_srcaddr, "srcaddr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400213 { Opt_ignore, "prefixpath=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400214 { Opt_iocharset, "iocharset=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400215 { Opt_netbiosname, "netbiosname=%s" },
216 { Opt_servern, "servern=%s" },
217 { Opt_ver, "ver=%s" },
Jeff Layton23db65f2012-05-15 12:20:51 -0400218 { Opt_vers, "vers=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400219 { Opt_sec, "sec=%s" },
Jeff Layton15b6a472012-05-16 07:50:15 -0400220 { Opt_cache, "cache=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400221
222 { Opt_ignore, "cred" },
223 { Opt_ignore, "credentials" },
Jeff Laytona557b972012-05-02 14:02:40 -0400224 { Opt_ignore, "cred=%s" },
225 { Opt_ignore, "credentials=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400226 { Opt_ignore, "guest" },
227 { Opt_ignore, "rw" },
228 { Opt_ignore, "ro" },
229 { Opt_ignore, "suid" },
230 { Opt_ignore, "nosuid" },
231 { Opt_ignore, "exec" },
232 { Opt_ignore, "noexec" },
233 { Opt_ignore, "nodev" },
234 { Opt_ignore, "noauto" },
235 { Opt_ignore, "dev" },
236 { Opt_ignore, "mand" },
237 { Opt_ignore, "nomand" },
238 { Opt_ignore, "_netdev" },
239
240 { Opt_err, NULL }
241};
242
243enum {
244 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
245 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
Jeff Layton76596242012-07-23 20:34:17 -0400246 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
247 Opt_sec_ntlmv2i, Opt_sec_lanman,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400248 Opt_sec_none,
249
250 Opt_sec_err
251};
252
253static const match_table_t cifs_secflavor_tokens = {
254 { Opt_sec_krb5, "krb5" },
255 { Opt_sec_krb5i, "krb5i" },
256 { Opt_sec_krb5p, "krb5p" },
257 { Opt_sec_ntlmsspi, "ntlmsspi" },
258 { Opt_sec_ntlmssp, "ntlmssp" },
259 { Opt_ntlm, "ntlm" },
260 { Opt_sec_ntlmi, "ntlmi" },
Jeff Layton76596242012-07-23 20:34:17 -0400261 { Opt_sec_ntlmv2, "nontlm" },
262 { Opt_sec_ntlmv2, "ntlmv2" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400263 { Opt_sec_ntlmv2i, "ntlmv2i" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400264 { Opt_sec_lanman, "lanman" },
265 { Opt_sec_none, "none" },
266
267 { Opt_sec_err, NULL }
268};
269
Jeff Layton15b6a472012-05-16 07:50:15 -0400270/* cache flavors */
271enum {
272 Opt_cache_loose,
273 Opt_cache_strict,
274 Opt_cache_none,
275 Opt_cache_err
276};
277
278static const match_table_t cifs_cacheflavor_tokens = {
279 { Opt_cache_loose, "loose" },
280 { Opt_cache_strict, "strict" },
281 { Opt_cache_none, "none" },
282 { Opt_cache_err, NULL }
283};
284
Jeff Layton23db65f2012-05-15 12:20:51 -0400285static const match_table_t cifs_smb_version_tokens = {
286 { Smb_1, SMB1_VERSION_STRING },
Steve Frenchdd446b12012-11-28 23:21:06 -0600287 { Smb_20, SMB20_VERSION_STRING},
Steve French1080ef72011-02-24 18:07:19 +0000288 { Smb_21, SMB21_VERSION_STRING },
Steve Frenche4aa25e2012-10-01 12:26:22 -0500289 { Smb_30, SMB30_VERSION_STRING },
Steve French20b6d8b2013-06-12 22:48:41 -0500290 { Smb_302, SMB302_VERSION_STRING },
Steve French5f7fbf72014-12-17 22:52:58 -0600291#ifdef CONFIG_CIFS_SMB311
292 { Smb_311, SMB311_VERSION_STRING },
Steve Frenchaab18932015-06-23 23:37:11 -0500293 { Smb_311, ALT_SMB311_VERSION_STRING },
Steve French5f7fbf72014-12-17 22:52:58 -0600294#endif /* SMB311 */
295 { Smb_version_err, NULL }
Jeff Layton23db65f2012-05-15 12:20:51 -0400296};
297
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300298static int ip_connect(struct TCP_Server_Info *server);
299static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400300static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400301static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -0400302static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
303 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Jeff Laytond5c56052008-12-01 18:42:33 -0500305/*
306 * cifs tcp session reconnection
307 *
308 * mark tcp session as reconnecting so temporarily locked
309 * mark all smb sessions as reconnecting for tcp session
310 * reconnect tcp session
311 * wake up waiters on reconnection? - (not needed currently)
312 */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400313int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314cifs_reconnect(struct TCP_Server_Info *server)
315{
316 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500317 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000318 struct cifs_ses *ses;
319 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000320 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400321 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +0000322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000324 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000325 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 next time through the loop */
327 spin_unlock(&GlobalMid_Lock);
328 return rc;
329 } else
330 server->tcpStatus = CifsNeedReconnect;
331 spin_unlock(&GlobalMid_Lock);
332 server->maxBuf = 0;
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400333#ifdef CONFIG_CIFS_SMB2
334 server->max_read = 0;
335#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Joe Perchesf96637b2013-05-04 22:12:25 -0500337 cifs_dbg(FYI, "Reconnecting tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 /* before reconnecting the tcp session, mark the smb session (uid)
340 and the tid bad so they are not used until reconnected */
Joe Perchesf96637b2013-05-04 22:12:25 -0500341 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
342 __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530343 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500344 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000345 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500346 ses->need_reconnect = true;
347 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500348 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000349 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500350 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530353 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 /* do not want to be sending data on a socket we are freeing */
Joe Perchesf96637b2013-05-04 22:12:25 -0500356 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500357 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000358 if (server->ssocket) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500359 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
360 server->ssocket->state, server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800361 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesf96637b2013-05-04 22:12:25 -0500362 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
363 server->ssocket->state, server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 sock_release(server->ssocket);
365 server->ssocket = NULL;
366 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500367 server->sequence_number = 0;
368 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500369 kfree(server->session_key.response);
370 server->session_key.response = NULL;
371 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000372 server->lstrp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500374 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400375 INIT_LIST_HEAD(&retry_list);
Joe Perchesf96637b2013-05-04 22:12:25 -0500376 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500378 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
379 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400380 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
381 mid_entry->mid_state = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400382 list_move(&mid_entry->qhead, &retry_list);
383 }
384 spin_unlock(&GlobalMid_Lock);
Rabin Vincent820962d2015-12-23 07:32:41 +0100385 mutex_unlock(&server->srv_mutex);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400386
Joe Perchesf96637b2013-05-04 22:12:25 -0500387 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400388 list_for_each_safe(tmp, tmp2, &retry_list) {
389 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500390 list_del_init(&mid_entry->qhead);
391 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400394 do {
Steve French6c3d8902006-07-31 22:46:20 +0000395 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300396
397 /* we should try only the port we connected to before */
Jeff Layton73e216a2013-09-05 08:38:10 -0400398 mutex_lock(&server->srv_mutex);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300399 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000400 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500401 cifs_dbg(FYI, "reconnect error %d\n", rc);
Federico Sauter4afe2602015-03-17 17:45:28 +0100402 mutex_unlock(&server->srv_mutex);
Steve French0cb766a2005-04-28 22:41:11 -0700403 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 } else {
405 atomic_inc(&tcpSesReconnectCount);
406 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000407 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000408 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000409 spin_unlock(&GlobalMid_Lock);
Federico Sauter4afe2602015-03-17 17:45:28 +0100410 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 }
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400412 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return rc;
415}
416
Jeff Laytonc74093b2011-01-11 07:24:23 -0500417static void
418cifs_echo_request(struct work_struct *work)
419{
420 int rc;
421 struct TCP_Server_Info *server = container_of(work,
422 struct TCP_Server_Info, echo.work);
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600423 unsigned long echo_interval = server->echo_interval;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500424
Jeff Layton247ec9b2011-02-04 17:09:50 -0500425 /*
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400426 * We cannot send an echo if it is disabled or until the
427 * NEGOTIATE_PROTOCOL request is done, which is indicated by
428 * server->ops->need_neg() == true. Also, no need to ping if
429 * we got a response recently.
Jeff Layton247ec9b2011-02-04 17:09:50 -0500430 */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400431 if (!server->ops->need_neg || server->ops->need_neg(server) ||
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400432 (server->ops->can_echo && !server->ops->can_echo(server)) ||
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600433 time_before(jiffies, server->lstrp + echo_interval - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500434 goto requeue_echo;
435
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400436 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500437 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500438 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
439 server->hostname);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500440
441requeue_echo:
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600442 queue_delayed_work(cifsiod_wq, &server->echo, echo_interval);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500443}
444
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400445static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400446allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400447{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400448 if (!server->bigbuf) {
449 server->bigbuf = (char *)cifs_buf_get();
450 if (!server->bigbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500451 cifs_dbg(VFS, "No memory for large SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400452 msleep(3000);
453 /* retry will check if exiting */
454 return false;
455 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400456 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400457 /* we are reusing a dirty large buf, clear its start */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400458 memset(server->bigbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400459 }
460
Jeff Layton2a37ef92011-10-19 15:29:23 -0400461 if (!server->smallbuf) {
462 server->smallbuf = (char *)cifs_small_buf_get();
463 if (!server->smallbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500464 cifs_dbg(VFS, "No memory for SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400465 msleep(1000);
466 /* retry will check if exiting */
467 return false;
468 }
469 /* beginning of smb buffer is cleared in our buf_get */
470 } else {
471 /* if existing small buf clear beginning */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400472 memset(server->smallbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400473 }
474
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400475 return true;
476}
477
Jeff Laytonba749e62011-10-11 06:41:32 -0400478static bool
479server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400480{
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300481 /*
482 * We need to wait 2 echo intervals to make sure we handle such
483 * situations right:
484 * 1s client sends a normal SMB request
485 * 2s client gets a response
486 * 30s echo workqueue job pops, and decides we got a response recently
487 * and don't need to send another
488 * ...
489 * 65s kernel_recvmsg times out, and we see that we haven't gotten
490 * a response in >60s.
491 */
492 if (server->tcpStatus == CifsGood &&
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600493 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
494 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
495 server->hostname, (2 * server->echo_interval) / HZ);
Jeff Laytonba749e62011-10-11 06:41:32 -0400496 cifs_reconnect(server);
497 wake_up(&server->response_q);
498 return true;
499 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400500
Jeff Laytonba749e62011-10-11 06:41:32 -0400501 return false;
502}
503
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400504/*
505 * kvec_array_init - clone a kvec array, and advance into it
506 * @new: pointer to memory for cloned array
507 * @iov: pointer to original array
508 * @nr_segs: number of members in original array
509 * @bytes: number of bytes to advance into the cloned array
510 *
511 * This function will copy the array provided in iov to a section of memory
512 * and advance the specified number of bytes into the new array. It returns
513 * the number of segments in the new array. "new" must be at least as big as
514 * the original iov array.
515 */
516static unsigned int
517kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
518 size_t bytes)
519{
520 size_t base = 0;
521
522 while (bytes || !iov->iov_len) {
523 int copy = min(bytes, iov->iov_len);
524
525 bytes -= copy;
526 base += copy;
527 if (iov->iov_len == base) {
528 iov++;
529 nr_segs--;
530 base = 0;
531 }
532 }
533 memcpy(new, iov, sizeof(*iov) * nr_segs);
534 new->iov_base += base;
535 new->iov_len -= base;
536 return nr_segs;
537}
538
Jeff Layton1041e3f2011-10-19 15:28:27 -0400539static struct kvec *
540get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
541{
542 struct kvec *new_iov;
543
544 if (server->iov && nr_segs <= server->nr_iov)
545 return server->iov;
546
547 /* not big enough -- allocate a new one and release the old */
548 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
549 if (new_iov) {
550 kfree(server->iov);
551 server->iov = new_iov;
552 server->nr_iov = nr_segs;
553 }
554 return new_iov;
555}
556
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400557int
558cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
559 unsigned int nr_segs, unsigned int to_read)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400560{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400561 int length = 0;
562 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400563 unsigned int segs;
Jeff Laytone831e6c2011-10-11 06:41:32 -0400564 struct msghdr smb_msg;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400565 struct kvec *iov;
566
Jeff Layton1041e3f2011-10-19 15:28:27 -0400567 iov = get_server_iovec(server, nr_segs);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400568 if (!iov)
569 return -ENOMEM;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400570
Jeff Laytone831e6c2011-10-11 06:41:32 -0400571 smb_msg.msg_control = NULL;
572 smb_msg.msg_controllen = 0;
573
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400574 for (total_read = 0; to_read; total_read += length, to_read -= length) {
Jeff Layton95edcff2011-12-01 20:22:41 -0500575 try_to_freeze();
576
Jeff Laytonba749e62011-10-11 06:41:32 -0400577 if (server_unresponsive(server)) {
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400578 total_read = -ECONNABORTED;
Jeff Laytonba749e62011-10-11 06:41:32 -0400579 break;
580 }
581
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400582 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
583
584 length = kernel_recvmsg(server->ssocket, &smb_msg,
585 iov, segs, to_read, 0);
586
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400587 if (server->tcpStatus == CifsExiting) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400588 total_read = -ESHUTDOWN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400589 break;
590 } else if (server->tcpStatus == CifsNeedReconnect) {
591 cifs_reconnect(server);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400592 total_read = -ECONNABORTED;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400593 break;
594 } else if (length == -ERESTARTSYS ||
595 length == -EAGAIN ||
596 length == -EINTR) {
597 /*
598 * Minimum sleep to prevent looping, allowing socket
599 * to clear and app threads to set tcpStatus
600 * CifsNeedReconnect if server hung.
601 */
602 usleep_range(1000, 2000);
603 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400604 continue;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400605 } else if (length <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500606 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
607 "got %d", to_read, length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400608 cifs_reconnect(server);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400609 total_read = -ECONNABORTED;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400610 break;
611 }
612 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400613 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400614}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400615
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400616int
617cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
618 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400619{
620 struct kvec iov;
621
622 iov.iov_base = buf;
623 iov.iov_len = to_read;
624
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400625 return cifs_readv_from_socket(server, &iov, 1, to_read);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400626}
627
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400628static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400629is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400630{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400631 /*
632 * The first byte big endian of the length field,
633 * is actually not part of the length but the type
634 * with the most common, zero, as regular data.
635 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400636 switch (type) {
637 case RFC1002_SESSION_MESSAGE:
638 /* Regular SMB response */
639 return true;
640 case RFC1002_SESSION_KEEP_ALIVE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500641 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400642 break;
643 case RFC1002_POSITIVE_SESSION_RESPONSE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500644 cifs_dbg(FYI, "RFC 1002 positive session response\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400645 break;
646 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400647 /*
648 * We get this from Windows 98 instead of an error on
649 * SMB negprot response.
650 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500651 cifs_dbg(FYI, "RFC 1002 negative session response\n");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400652 /* give server a second to clean up */
653 msleep(1000);
654 /*
655 * Always try 445 first on reconnect since we get NACK
656 * on some if we ever connected to port 139 (the NACK
657 * is since we do not begin with RFC1001 session
658 * initialize frame).
659 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400660 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400661 cifs_reconnect(server);
662 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400663 break;
664 default:
Joe Perchesf96637b2013-05-04 22:12:25 -0500665 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400666 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400667 }
668
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400669 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400670}
671
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400672void
673dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400674{
675#ifdef CONFIG_CIFS_STATS2
676 mid->when_received = jiffies;
677#endif
678 spin_lock(&GlobalMid_Lock);
679 if (!malformed)
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400680 mid->mid_state = MID_RESPONSE_RECEIVED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400681 else
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400682 mid->mid_state = MID_RESPONSE_MALFORMED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400683 list_del_init(&mid->qhead);
684 spin_unlock(&GlobalMid_Lock);
685}
686
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400687static void
688handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400689 char *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400690{
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400691 if (server->ops->check_trans2 &&
692 server->ops->check_trans2(mid, server, buf, malformed))
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400693 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400694 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400695 mid->large_buf = server->large_buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400696 /* Was previous buf put in mpx struct for multi-rsp? */
697 if (!mid->multiRsp) {
698 /* smb buffer will be freed by user thread */
699 if (server->large_buf)
700 server->bigbuf = NULL;
701 else
702 server->smallbuf = NULL;
703 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400704 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400705}
706
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400707static void clean_demultiplex_info(struct TCP_Server_Info *server)
708{
709 int length;
710
711 /* take it off the list, if it's not already */
712 spin_lock(&cifs_tcp_ses_lock);
713 list_del_init(&server->tcp_ses_list);
714 spin_unlock(&cifs_tcp_ses_lock);
715
716 spin_lock(&GlobalMid_Lock);
717 server->tcpStatus = CifsExiting;
718 spin_unlock(&GlobalMid_Lock);
719 wake_up_all(&server->response_q);
720
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400721 /* check if we have blocked requests that need to free */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300722 spin_lock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400723 if (server->credits <= 0)
724 server->credits = 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300725 spin_unlock(&server->req_lock);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400726 /*
727 * Although there should not be any requests blocked on this queue it
728 * can not hurt to be paranoid and try to wake up requests that may
729 * haven been blocked when more than 50 at time were on the wire to the
730 * same server - they now will see the session is in exit state and get
731 * out of SendReceive.
732 */
733 wake_up_all(&server->request_q);
734 /* give those requests time to exit */
735 msleep(125);
736
737 if (server->ssocket) {
738 sock_release(server->ssocket);
739 server->ssocket = NULL;
740 }
741
742 if (!list_empty(&server->pending_mid_q)) {
743 struct list_head dispose_list;
744 struct mid_q_entry *mid_entry;
745 struct list_head *tmp, *tmp2;
746
747 INIT_LIST_HEAD(&dispose_list);
748 spin_lock(&GlobalMid_Lock);
749 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
750 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500751 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400752 mid_entry->mid_state = MID_SHUTDOWN;
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400753 list_move(&mid_entry->qhead, &dispose_list);
754 }
755 spin_unlock(&GlobalMid_Lock);
756
757 /* now walk dispose list and issue callbacks */
758 list_for_each_safe(tmp, tmp2, &dispose_list) {
759 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500760 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400761 list_del_init(&mid_entry->qhead);
762 mid_entry->callback(mid_entry);
763 }
764 /* 1/8th of sec is more than enough time for them to exit */
765 msleep(125);
766 }
767
768 if (!list_empty(&server->pending_mid_q)) {
769 /*
770 * mpx threads have not exited yet give them at least the smb
771 * send timeout time for long ops.
772 *
773 * Due to delays on oplock break requests, we need to wait at
774 * least 45 seconds before giving up on a request getting a
775 * response and going ahead and killing cifsd.
776 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500777 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400778 msleep(46000);
779 /*
780 * If threads still have not exited they are probably never
781 * coming home not much else we can do but free the memory.
782 */
783 }
784
785 kfree(server->hostname);
Jeff Layton1041e3f2011-10-19 15:28:27 -0400786 kfree(server->iov);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400787 kfree(server);
788
789 length = atomic_dec_return(&tcpSesAllocCount);
790 if (length > 0)
David Rientjes11d83362015-04-14 15:48:21 -0700791 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400792}
793
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400794static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400795standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
796{
797 int length;
798 char *buf = server->smallbuf;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400799 unsigned int pdu_length = get_rfc1002_length(buf);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400800
801 /* make sure this will fit in a large buffer */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400802 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500803 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400804 cifs_reconnect(server);
805 wake_up(&server->response_q);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400806 return -ECONNABORTED;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400807 }
808
809 /* switch to large buffer if too big for a small one */
810 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
811 server->large_buf = true;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400812 memcpy(server->bigbuf, buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400813 buf = server->bigbuf;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400814 }
815
816 /* now read the rest */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400817 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
818 pdu_length - HEADER_SIZE(server) + 1 + 4);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400819 if (length < 0)
820 return length;
821 server->total_read += length;
822
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400823 dump_smb(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400824
825 /*
826 * We know that we received enough to get to the MID as we
827 * checked the pdu_length earlier. Now check to see
828 * if the rest of the header is OK. We borrow the length
829 * var for the rest of the loop to avoid a new stack var.
830 *
831 * 48 bytes is enough to display the header and a little bit
832 * into the payload for debugging purposes.
833 */
Steve French373512e2015-12-18 13:05:30 -0600834 length = server->ops->check_message(buf, server->total_read, server);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400835 if (length != 0)
836 cifs_dump_mem("Bad SMB: ", buf,
837 min_t(unsigned int, server->total_read, 48));
838
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700839 if (server->ops->is_status_pending &&
840 server->ops->is_status_pending(buf, server, length))
841 return -1;
842
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500843 if (!mid)
844 return length;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400845
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400846 handle_mid(mid, server, buf, length);
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500847 return 0;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400848}
849
850static int
Al Viro7c97c202011-06-21 08:51:28 -0400851cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852{
853 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400854 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400855 unsigned int pdu_length;
856 char *buf = NULL;
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500857 struct task_struct *task_to_wake = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 current->flags |= PF_MEMALLOC;
Joe Perchesf96637b2013-05-04 22:12:25 -0500861 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400862
863 length = atomic_inc_return(&tcpSesAllocCount);
864 if (length > 1)
David Rientjes11d83362015-04-14 15:48:21 -0700865 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700867 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000868 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700869 if (try_to_freeze())
870 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700871
Jeff Layton2a37ef92011-10-19 15:29:23 -0400872 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400873 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700874
Jeff Layton2a37ef92011-10-19 15:29:23 -0400875 server->large_buf = false;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400876 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000877 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000878
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400879 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400880 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +0000881 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400882 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -0700883
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400884 /*
885 * The right amount was read from socket - 4 bytes,
886 * so we can now interpret the length field.
887 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400888 pdu_length = get_rfc1002_length(buf);
Steve French46810cb2005-04-28 22:41:09 -0700889
Joe Perchesf96637b2013-05-04 22:12:25 -0500890 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400891 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000892 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700893
Jeff Layton89482a52011-10-19 15:28:57 -0400894 /* make sure we have enough to get to the MID */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400895 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500896 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
897 pdu_length);
Jeff Layton89482a52011-10-19 15:28:57 -0400898 cifs_reconnect(server);
899 wake_up(&server->response_q);
900 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700901 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400902
Jeff Layton89482a52011-10-19 15:28:57 -0400903 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400904 length = cifs_read_from_socket(server, buf + 4,
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400905 HEADER_SIZE(server) - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -0400906 if (length < 0)
907 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400908 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -0400909
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400910 mid_entry = server->ops->find_mid(server, buf);
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400911
Jeff Layton44d22d82011-10-19 15:29:49 -0400912 if (!mid_entry || !mid_entry->receive)
913 length = standard_receive3(server, mid_entry);
914 else
915 length = mid_entry->receive(server, mid_entry);
916
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400917 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700918 continue;
919
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400920 if (server->large_buf)
Jeff Laytone9097ab2011-10-19 15:29:40 -0400921 buf = server->bigbuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700922
Steve Frenchfda35942011-01-20 18:06:34 +0000923 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500924 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -0400925 if (!mid_entry->multiRsp || mid_entry->multiEnd)
926 mid_entry->callback(mid_entry);
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400927 } else if (!server->ops->is_oplock_break ||
928 !server->ops->is_oplock_break(buf, server)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500929 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
930 atomic_read(&midCount));
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400931 cifs_dump_mem("Received Data is: ", buf,
932 HEADER_SIZE(server));
Steve French39798772006-05-31 22:40:51 +0000933#ifdef CONFIG_CIFS_DEBUG2
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400934 if (server->ops->dump_detail)
935 server->ops->dump_detail(buf);
Steve French39798772006-05-31 22:40:51 +0000936 cifs_dump_mids(server);
937#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000938
Steve Frenche4eb2952005-04-28 22:41:09 -0700939 }
940 } /* end while !EXITING */
941
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800942 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400943 cifs_buf_release(server->bigbuf);
944 if (server->smallbuf) /* no sense logging a debug message if NULL */
945 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500947 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400948 clean_demultiplex_info(server);
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500949
950 /* if server->tsk was NULL then wait for a signal before exiting */
951 if (!task_to_wake) {
952 set_current_state(TASK_INTERRUPTIBLE);
953 while (!signal_pending(current)) {
954 schedule();
955 set_current_state(TASK_INTERRUPTIBLE);
956 }
957 set_current_state(TASK_RUNNING);
958 }
959
Jeff Layton0468a2c2008-12-01 07:09:35 -0500960 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961}
962
Jeff Laytonc359cf32007-11-16 22:22:06 +0000963/* extract the host portion of the UNC string */
964static char *
965extract_hostname(const char *unc)
966{
967 const char *src;
968 char *dst, *delim;
969 unsigned int len;
970
971 /* skip double chars at beginning of string */
972 /* BB: check validity of these bytes? */
973 src = unc + 2;
974
975 /* delimiter between hostname and sharename is always '\\' now */
976 delim = strchr(src, '\\');
977 if (!delim)
978 return ERR_PTR(-EINVAL);
979
980 len = delim - src;
981 dst = kmalloc((len + 1), GFP_KERNEL);
982 if (dst == NULL)
983 return ERR_PTR(-ENOMEM);
984
985 memcpy(dst, src, len);
986 dst[len] = '\0';
987
988 return dst;
989}
990
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400991static int get_option_ul(substring_t args[], unsigned long *option)
992{
993 int rc;
994 char *string;
995
996 string = match_strdup(args);
997 if (string == NULL)
998 return -ENOMEM;
Sachin Prabhubfa890a2012-04-13 14:04:32 +0100999 rc = kstrtoul(string, 0, option);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001000 kfree(string);
1001
1002 return rc;
1003}
1004
Eric W. Biederman3da46562013-02-06 01:37:39 -08001005static int get_option_uid(substring_t args[], kuid_t *result)
1006{
1007 unsigned long value;
1008 kuid_t uid;
1009 int rc;
1010
1011 rc = get_option_ul(args, &value);
1012 if (rc)
1013 return rc;
1014
1015 uid = make_kuid(current_user_ns(), value);
1016 if (!uid_valid(uid))
1017 return -EINVAL;
1018
1019 *result = uid;
1020 return 0;
1021}
1022
1023static int get_option_gid(substring_t args[], kgid_t *result)
1024{
1025 unsigned long value;
1026 kgid_t gid;
1027 int rc;
1028
1029 rc = get_option_ul(args, &value);
1030 if (rc)
1031 return rc;
1032
1033 gid = make_kgid(current_user_ns(), value);
1034 if (!gid_valid(gid))
1035 return -EINVAL;
1036
1037 *result = gid;
1038 return 0;
1039}
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001040
1041static int cifs_parse_security_flavors(char *value,
1042 struct smb_vol *vol)
1043{
1044
1045 substring_t args[MAX_OPT_ARGS];
1046
Jeff Layton1e3cc572013-06-10 17:12:23 -05001047 /*
1048 * With mount options, the last one should win. Reset any existing
1049 * settings back to default.
1050 */
1051 vol->sectype = Unspecified;
1052 vol->sign = false;
1053
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001054 switch (match_token(value, cifs_secflavor_tokens, args)) {
Jeff Layton3f618222013-06-12 19:52:14 -05001055 case Opt_sec_krb5p:
1056 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1057 return 1;
1058 case Opt_sec_krb5i:
1059 vol->sign = true;
1060 /* Fallthrough */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001061 case Opt_sec_krb5:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001062 vol->sectype = Kerberos;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001063 break;
1064 case Opt_sec_ntlmsspi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001065 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001066 /* Fallthrough */
1067 case Opt_sec_ntlmssp:
1068 vol->sectype = RawNTLMSSP;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001069 break;
1070 case Opt_sec_ntlmi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001071 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001072 /* Fallthrough */
1073 case Opt_ntlm:
1074 vol->sectype = NTLM;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001075 break;
1076 case Opt_sec_ntlmv2i:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001077 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001078 /* Fallthrough */
1079 case Opt_sec_ntlmv2:
1080 vol->sectype = NTLMv2;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001081 break;
1082#ifdef CONFIG_CIFS_WEAK_PW_HASH
1083 case Opt_sec_lanman:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001084 vol->sectype = LANMAN;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001085 break;
1086#endif
1087 case Opt_sec_none:
1088 vol->nullauth = 1;
1089 break;
1090 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001091 cifs_dbg(VFS, "bad security option: %s\n", value);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001092 return 1;
1093 }
1094
1095 return 0;
1096}
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098static int
Jeff Layton15b6a472012-05-16 07:50:15 -04001099cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1100{
1101 substring_t args[MAX_OPT_ARGS];
1102
1103 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1104 case Opt_cache_loose:
1105 vol->direct_io = false;
1106 vol->strict_io = false;
1107 break;
1108 case Opt_cache_strict:
1109 vol->direct_io = false;
1110 vol->strict_io = true;
1111 break;
1112 case Opt_cache_none:
1113 vol->direct_io = true;
1114 vol->strict_io = false;
1115 break;
1116 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001117 cifs_dbg(VFS, "bad cache= option: %s\n", value);
Jeff Layton15b6a472012-05-16 07:50:15 -04001118 return 1;
1119 }
1120 return 0;
1121}
1122
1123static int
Jeff Layton23db65f2012-05-15 12:20:51 -04001124cifs_parse_smb_version(char *value, struct smb_vol *vol)
1125{
1126 substring_t args[MAX_OPT_ARGS];
1127
1128 switch (match_token(value, cifs_smb_version_tokens, args)) {
1129 case Smb_1:
1130 vol->ops = &smb1_operations;
1131 vol->vals = &smb1_values;
1132 break;
Steve French1080ef72011-02-24 18:07:19 +00001133#ifdef CONFIG_CIFS_SMB2
Steve Frenchdd446b12012-11-28 23:21:06 -06001134 case Smb_20:
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001135 vol->ops = &smb20_operations;
Steve Frenchdd446b12012-11-28 23:21:06 -06001136 vol->vals = &smb20_values;
1137 break;
Steve French1080ef72011-02-24 18:07:19 +00001138 case Smb_21:
1139 vol->ops = &smb21_operations;
1140 vol->vals = &smb21_values;
1141 break;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001142 case Smb_30:
Steve French38107d42012-12-08 22:08:06 -06001143 vol->ops = &smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001144 vol->vals = &smb30_values;
1145 break;
Steve French20b6d8b2013-06-12 22:48:41 -05001146 case Smb_302:
1147 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1148 vol->vals = &smb302_values;
1149 break;
Steve French5f7fbf72014-12-17 22:52:58 -06001150#ifdef CONFIG_CIFS_SMB311
1151 case Smb_311:
Steve Frenchaab18932015-06-23 23:37:11 -05001152 vol->ops = &smb311_operations;
Steve French5f7fbf72014-12-17 22:52:58 -06001153 vol->vals = &smb311_values;
1154 break;
1155#endif /* SMB311 */
Steve French1080ef72011-02-24 18:07:19 +00001156#endif
Jeff Layton23db65f2012-05-15 12:20:51 -04001157 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001158 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
Jeff Layton23db65f2012-05-15 12:20:51 -04001159 return 1;
1160 }
1161 return 0;
1162}
1163
Jeff Laytond387a5c2012-12-10 06:10:46 -05001164/*
1165 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1166 * fields with the result. Returns 0 on success and an error otherwise.
1167 */
1168static int
1169cifs_parse_devname(const char *devname, struct smb_vol *vol)
1170{
1171 char *pos;
1172 const char *delims = "/\\";
1173 size_t len;
1174
1175 /* make sure we have a valid UNC double delimiter prefix */
1176 len = strspn(devname, delims);
1177 if (len != 2)
1178 return -EINVAL;
1179
1180 /* find delimiter between host and sharename */
1181 pos = strpbrk(devname + 2, delims);
1182 if (!pos)
1183 return -EINVAL;
1184
1185 /* skip past delimiter */
1186 ++pos;
1187
1188 /* now go until next delimiter or end of string */
1189 len = strcspn(pos, delims);
1190
1191 /* move "pos" up to delimiter or NULL */
1192 pos += len;
1193 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1194 if (!vol->UNC)
1195 return -ENOMEM;
1196
1197 convert_delimiter(vol->UNC, '\\');
1198
1199 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1200 if (!*pos++ || !*pos)
1201 return 0;
1202
1203 vol->prepath = kstrdup(pos, GFP_KERNEL);
1204 if (!vol->prepath)
1205 return -ENOMEM;
1206
1207 return 0;
1208}
1209
Jeff Layton23db65f2012-05-15 12:20:51 -04001210static int
Sean Finneyb9468452011-04-11 13:19:32 +00001211cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +00001212 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213{
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001214 char *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +04001215 char *mountdata_copy = NULL, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 unsigned int temp_len, i, j;
1217 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001218 short int override_uid = -1;
1219 short int override_gid = -1;
1220 bool uid_specified = false;
1221 bool gid_specified = false;
Jeff Laytond8162552012-03-23 14:40:56 -04001222 bool sloppy = false;
1223 char *invalid = NULL;
Jeff Layton88463992010-11-22 15:31:03 -05001224 char *nodename = utsname()->nodename;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001225 char *string = NULL;
1226 char *tmp_end, *value;
1227 char delim;
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001228 bool got_ip = false;
1229 unsigned short port = 0;
1230 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
1232 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +00001233 separator[1] = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001234 delim = separator[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Jeff Layton6ee95422012-11-26 11:09:57 -05001236 /* ensure we always start with zeroed-out smb_vol */
1237 memset(vol, 0, sizeof(*vol));
1238
Jeff Layton88463992010-11-22 15:31:03 -05001239 /*
1240 * does not have to be perfect mapping since field is
1241 * informational, only used for servers that do not support
1242 * port 445 and it can be overridden at mount time
1243 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001244 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1245 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -05001246 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1247
Jeff Layton1397f2e2011-01-07 11:30:28 -05001248 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -07001249 /* null target name indicates to use *SMBSERVR default called name
1250 if we end up sending RFC1001 session initialize */
1251 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001252 vol->cred_uid = current_uid();
1253 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +11001254 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001255
Steve French2baa2682014-09-27 02:19:01 -05001256 /*
1257 * default to SFM style remapping of seven reserved characters
1258 * unless user overrides it or we negotiate CIFS POSIX where
1259 * it is unnecessary. Can not simultaneously use more than one mapping
1260 * since then readdir could list files that open could not open
1261 */
1262 vol->remap = true;
1263
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001264 /* default to only allowing write access to owner of the mount */
1265 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
1267 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -07001268 /* default is always to request posix paths. */
1269 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -04001270 /* default to using server inode numbers where available */
1271 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001272
Jeff Layton1b359202012-09-19 15:20:27 -07001273 /* default is to use strict cifs caching semantics */
1274 vol->strict_io = true;
1275
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301276 vol->actimeo = CIFS_DEF_ACTIMEO;
1277
Jeff Layton23db65f2012-05-15 12:20:51 -04001278 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1279 vol->ops = &smb1_operations;
1280 vol->vals = &smb1_values;
1281
Sean Finneyb9468452011-04-11 13:19:32 +00001282 if (!mountdata)
1283 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
Sean Finneyb9468452011-04-11 13:19:32 +00001285 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1286 if (!mountdata_copy)
1287 goto cifs_parse_mount_err;
1288
1289 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001290 end = options + strlen(options);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001291
Steve French50c2f752007-07-13 00:33:32 +00001292 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001293 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 separator[0] = options[4];
1295 options += 5;
1296 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001297 cifs_dbg(FYI, "Null separator not allowed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 }
1299 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001300 vol->backupuid_specified = false; /* no backup intent for a user */
1301 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +00001302
Jeff Layton37d4f992013-05-24 07:40:05 -04001303 switch (cifs_parse_devname(devname, vol)) {
1304 case 0:
1305 break;
1306 case -ENOMEM:
1307 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1308 goto cifs_parse_mount_err;
1309 case -EINVAL:
1310 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1311 goto cifs_parse_mount_err;
1312 default:
1313 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1314 goto cifs_parse_mount_err;
Jeff Laytond387a5c2012-12-10 06:10:46 -05001315 }
1316
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 while ((data = strsep(&options, separator)) != NULL) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001318 substring_t args[MAX_OPT_ARGS];
1319 unsigned long option;
1320 int token;
1321
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 if (!*data)
1323 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001325 token = match_token(data, cifs_mount_option_tokens, args);
1326
1327 switch (token) {
1328
1329 /* Ingnore the following */
1330 case Opt_ignore:
1331 break;
1332
1333 /* Boolean values */
1334 case Opt_user_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 vol->no_xattr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001336 break;
1337 case Opt_nouser_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 vol->no_xattr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001339 break;
1340 case Opt_forceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001341 override_uid = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001342 break;
1343 case Opt_noforceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001344 override_uid = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001345 break;
Jeff Layton72bd4812012-10-03 16:02:36 -04001346 case Opt_forcegid:
1347 override_gid = 1;
1348 break;
1349 case Opt_noforcegid:
1350 override_gid = 0;
1351 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001352 case Opt_noblocksend:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001353 vol->noblocksnd = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001354 break;
1355 case Opt_noautotune:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001356 vol->noautotune = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001357 break;
1358 case Opt_hard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001360 break;
1361 case Opt_soft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001363 break;
1364 case Opt_perm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 vol->noperm = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001366 break;
1367 case Opt_noperm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 vol->noperm = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001369 break;
1370 case Opt_mapchars:
Steve French2baa2682014-09-27 02:19:01 -05001371 vol->sfu_remap = true;
1372 vol->remap = false; /* disable SFM mapping */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001373 break;
1374 case Opt_nomapchars:
Steve French2baa2682014-09-27 02:19:01 -05001375 vol->sfu_remap = false;
1376 break;
1377 case Opt_mapposix:
1378 vol->remap = true;
1379 vol->sfu_remap = false; /* disable SFU mapping */
1380 break;
1381 case Opt_nomapposix:
1382 vol->remap = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001383 break;
1384 case Opt_sfu:
Steve French50c2f752007-07-13 00:33:32 +00001385 vol->sfu_emul = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001386 break;
1387 case Opt_nosfu:
Steve French50c2f752007-07-13 00:33:32 +00001388 vol->sfu_emul = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001389 break;
1390 case Opt_nodfs:
Steve French2c1b8612008-10-16 18:35:21 +00001391 vol->nodfs = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001392 break;
1393 case Opt_posixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001394 vol->posix_paths = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001395 break;
1396 case Opt_noposixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001397 vol->posix_paths = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001398 break;
1399 case Opt_nounix:
Steve Frenchc18c8422007-07-18 23:21:09 +00001400 vol->no_linux_ext = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001401 break;
1402 case Opt_nocase:
Steve French50c2f752007-07-13 00:33:32 +00001403 vol->nocase = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001404 break;
1405 case Opt_brl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001406 vol->nobrl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001407 break;
1408 case Opt_nobrl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001409 vol->nobrl = 1;
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001410 /*
1411 * turn off mandatory locking in mode
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001412 * if remote locking is turned off since the
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001413 * local vfs will do advisory
1414 */
Steve French50c2f752007-07-13 00:33:32 +00001415 if (vol->file_mode ==
1416 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001417 vol->file_mode = S_IALLUGO;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001418 break;
1419 case Opt_forcemandatorylock:
Steve French13a6e422008-12-02 17:24:33 +00001420 vol->mand_lock = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001421 break;
1422 case Opt_setuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 vol->setuids = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001424 break;
1425 case Opt_nosetuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 vol->setuids = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001427 break;
1428 case Opt_dynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001429 vol->dynperm = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001430 break;
1431 case Opt_nodynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001432 vol->dynperm = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001433 break;
1434 case Opt_nohard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001436 break;
1437 case Opt_nosoft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001439 break;
1440 case Opt_nointr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 vol->intr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001442 break;
1443 case Opt_intr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 vol->intr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001445 break;
1446 case Opt_nostrictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001447 vol->nostrictsync = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001448 break;
1449 case Opt_strictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001450 vol->nostrictsync = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001451 break;
1452 case Opt_serverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 vol->server_ino = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001454 break;
1455 case Opt_noserverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 vol->server_ino = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001457 break;
1458 case Opt_rwpidforward:
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001459 vol->rwpidforward = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001460 break;
1461 case Opt_cifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001462 vol->cifs_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001463 break;
1464 case Opt_nocifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001465 vol->cifs_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001466 break;
1467 case Opt_acl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 vol->no_psx_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001469 break;
1470 case Opt_noacl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 vol->no_psx_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001472 break;
1473 case Opt_locallease:
Steve French84210e92008-10-23 04:42:37 +00001474 vol->local_lease = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001475 break;
1476 case Opt_sign:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001477 vol->sign = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001478 break;
1479 case Opt_seal:
Steve French95b1cb92008-05-15 16:44:38 +00001480 /* we do not do the following in secFlags because seal
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001481 * is a per tree connection (mount) not a per socket
1482 * or per-smb connection option in the protocol
1483 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1484 */
Steve French95b1cb92008-05-15 16:44:38 +00001485 vol->seal = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001486 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001487 case Opt_noac:
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001488 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001489 break;
1490 case Opt_fsc:
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301491#ifndef CONFIG_CIFS_FSCACHE
Joe Perchesf96637b2013-05-04 22:12:25 -05001492 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001493 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301494#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301495 vol->fsc = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001496 break;
1497 case Opt_mfsymlinks:
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001498 vol->mfsymlinks = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001499 break;
1500 case Opt_multiuser:
Jeff Layton0eb8a132010-10-06 19:51:12 -04001501 vol->multiuser = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001502 break;
Jeff Laytond8162552012-03-23 14:40:56 -04001503 case Opt_sloppy:
1504 sloppy = true;
1505 break;
Jeff Laytona0b3df52013-05-24 07:40:59 -04001506 case Opt_nosharesock:
1507 vol->nosharesock = true;
1508 break;
Steve Frenchb2a30772015-09-29 21:49:28 -05001509 case Opt_nopersistent:
1510 vol->nopersistent = true;
1511 if (vol->persistent) {
1512 cifs_dbg(VFS,
1513 "persistenthandles mount options conflict\n");
1514 goto cifs_parse_mount_err;
1515 }
1516 break;
1517 case Opt_persistent:
1518 vol->persistent = true;
Steve French592fafe2015-11-03 10:08:53 -06001519 if ((vol->nopersistent) || (vol->resilient)) {
Steve Frenchb2a30772015-09-29 21:49:28 -05001520 cifs_dbg(VFS,
1521 "persistenthandles mount options conflict\n");
1522 goto cifs_parse_mount_err;
1523 }
1524 break;
Steve French592fafe2015-11-03 10:08:53 -06001525 case Opt_resilient:
1526 vol->resilient = true;
1527 if (vol->persistent) {
1528 cifs_dbg(VFS,
1529 "persistenthandles mount options conflict\n");
1530 goto cifs_parse_mount_err;
1531 }
1532 break;
1533 case Opt_noresilient:
1534 vol->resilient = false; /* already the default */
1535 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001536
1537 /* Numeric Values */
1538 case Opt_backupuid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001539 if (get_option_uid(args, &vol->backupuid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001540 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1541 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001542 goto cifs_parse_mount_err;
1543 }
1544 vol->backupuid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001545 break;
1546 case Opt_backupgid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001547 if (get_option_gid(args, &vol->backupgid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001548 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1549 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001550 goto cifs_parse_mount_err;
1551 }
1552 vol->backupgid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001553 break;
1554 case Opt_uid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001555 if (get_option_uid(args, &vol->linux_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001556 cifs_dbg(VFS, "%s: Invalid uid value\n",
1557 __func__);
Sean Finneyb9468452011-04-11 13:19:32 +00001558 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001560 uid_specified = true;
1561 break;
1562 case Opt_cruid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001563 if (get_option_uid(args, &vol->cred_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001564 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1565 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001566 goto cifs_parse_mount_err;
1567 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001568 break;
1569 case Opt_gid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001570 if (get_option_gid(args, &vol->linux_gid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001571 cifs_dbg(VFS, "%s: Invalid gid value\n",
1572 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001573 goto cifs_parse_mount_err;
1574 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001575 gid_specified = true;
1576 break;
1577 case Opt_file_mode:
1578 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001579 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1580 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001581 goto cifs_parse_mount_err;
1582 }
1583 vol->file_mode = option;
1584 break;
1585 case Opt_dirmode:
1586 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001587 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1588 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001589 goto cifs_parse_mount_err;
1590 }
1591 vol->dir_mode = option;
1592 break;
1593 case Opt_port:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001594 if (get_option_ul(args, &option) ||
1595 option > USHRT_MAX) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001596 cifs_dbg(VFS, "%s: Invalid port value\n",
1597 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001598 goto cifs_parse_mount_err;
1599 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001600 port = (unsigned short)option;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001601 break;
1602 case Opt_rsize:
1603 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001604 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1605 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001606 goto cifs_parse_mount_err;
1607 }
1608 vol->rsize = option;
1609 break;
1610 case Opt_wsize:
1611 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001612 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1613 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001614 goto cifs_parse_mount_err;
1615 }
1616 vol->wsize = option;
1617 break;
1618 case Opt_actimeo:
1619 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001620 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1621 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001622 goto cifs_parse_mount_err;
1623 }
1624 vol->actimeo = HZ * option;
1625 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001626 cifs_dbg(VFS, "attribute cache timeout too large\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001627 goto cifs_parse_mount_err;
1628 }
1629 break;
Steve Frenchadfeb3e2015-12-18 12:31:36 -06001630 case Opt_echo_interval:
1631 if (get_option_ul(args, &option)) {
1632 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1633 __func__);
1634 goto cifs_parse_mount_err;
1635 }
1636 vol->echo_interval = option;
1637 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001638
1639 /* String Arguments */
1640
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001641 case Opt_blank_user:
1642 /* null user, ie. anonymous authentication */
1643 vol->nullauth = 1;
1644 vol->username = NULL;
1645 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001646 case Opt_user:
1647 string = match_strdup(args);
1648 if (string == NULL)
1649 goto out_nomem;
1650
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04001651 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1652 CIFS_MAX_USERNAME_LEN) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001653 pr_warn("CIFS: username too long\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001654 goto cifs_parse_mount_err;
1655 }
Taesoo Kim2bd50fb2015-03-21 19:08:30 -04001656
1657 kfree(vol->username);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001658 vol->username = kstrdup(string, GFP_KERNEL);
Joe Perchesf96637b2013-05-04 22:12:25 -05001659 if (!vol->username)
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001660 goto cifs_parse_mount_err;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001661 break;
1662 case Opt_blank_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001663 /* passwords have to be handled differently
1664 * to allow the character used for deliminator
1665 * to be passed within them
1666 */
1667
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001668 /*
1669 * Check if this is a case where the password
1670 * starts with a delimiter
1671 */
1672 tmp_end = strchr(data, '=');
1673 tmp_end++;
1674 if (!(tmp_end < end && tmp_end[1] == delim)) {
1675 /* No it is not. Set the password to NULL */
Namjae Jeond6ccf492014-08-21 19:11:20 +09001676 kfree(vol->password);
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001677 vol->password = NULL;
1678 break;
1679 }
1680 /* Yes it is. Drop down to Opt_pass below.*/
1681 case Opt_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001682 /* Obtain the value string */
1683 value = strchr(data, '=');
Sachin Prabhu10238072012-03-28 18:07:08 +01001684 value++;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001685
1686 /* Set tmp_end to end of the string */
1687 tmp_end = (char *) value + strlen(value);
1688
1689 /* Check if following character is the deliminator
1690 * If yes, we have encountered a double deliminator
1691 * reset the NULL character to the deliminator
1692 */
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301693 if (tmp_end < end && tmp_end[1] == delim) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001694 tmp_end[0] = delim;
1695
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301696 /* Keep iterating until we get to a single
1697 * deliminator OR the end
1698 */
1699 while ((tmp_end = strchr(tmp_end, delim))
1700 != NULL && (tmp_end[1] == delim)) {
1701 tmp_end = (char *) &tmp_end[2];
1702 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001703
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301704 /* Reset var options to point to next element */
1705 if (tmp_end) {
1706 tmp_end[0] = '\0';
1707 options = (char *) &tmp_end[1];
1708 } else
1709 /* Reached the end of the mount option
1710 * string */
1711 options = end;
1712 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001713
Namjae Jeond6ccf492014-08-21 19:11:20 +09001714 kfree(vol->password);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001715 /* Now build new password string */
1716 temp_len = strlen(value);
1717 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1718 if (vol->password == NULL) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001719 pr_warn("CIFS: no memory for password\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001720 goto cifs_parse_mount_err;
1721 }
1722
1723 for (i = 0, j = 0; i < temp_len; i++, j++) {
1724 vol->password[j] = value[i];
1725 if ((value[i] == delim) &&
1726 value[i+1] == delim)
1727 /* skip the second deliminator */
1728 i++;
1729 }
1730 vol->password[j] = '\0';
1731 break;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001732 case Opt_blank_ip:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001733 /* FIXME: should this be an error instead? */
1734 got_ip = false;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001735 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001736 case Opt_ip:
1737 string = match_strdup(args);
1738 if (string == NULL)
1739 goto out_nomem;
1740
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001741 if (!cifs_convert_address(dstaddr, string,
1742 strlen(string))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001743 pr_err("CIFS: bad ip= option (%s).\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001744 goto cifs_parse_mount_err;
1745 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001746 got_ip = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001747 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001748 case Opt_domain:
1749 string = match_strdup(args);
1750 if (string == NULL)
1751 goto out_nomem;
1752
Chen Gang057d6332013-07-19 09:01:36 +08001753 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1754 == CIFS_MAX_DOMAINNAME_LEN) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001755 pr_warn("CIFS: domain name too long\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001756 goto cifs_parse_mount_err;
1757 }
1758
Taesoo Kim2bd50fb2015-03-21 19:08:30 -04001759 kfree(vol->domainname);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001760 vol->domainname = kstrdup(string, GFP_KERNEL);
1761 if (!vol->domainname) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001762 pr_warn("CIFS: no memory for domainname\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001763 goto cifs_parse_mount_err;
1764 }
Joe Perchesf96637b2013-05-04 22:12:25 -05001765 cifs_dbg(FYI, "Domain name set\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001766 break;
1767 case Opt_srcaddr:
1768 string = match_strdup(args);
1769 if (string == NULL)
1770 goto out_nomem;
1771
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001772 if (!cifs_convert_address(
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001773 (struct sockaddr *)&vol->srcaddr,
1774 string, strlen(string))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001775 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1776 string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001777 goto cifs_parse_mount_err;
1778 }
1779 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001780 case Opt_iocharset:
1781 string = match_strdup(args);
1782 if (string == NULL)
1783 goto out_nomem;
1784
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001785 if (strnlen(string, 1024) >= 65) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001786 pr_warn("CIFS: iocharset name too long.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001787 goto cifs_parse_mount_err;
1788 }
1789
Rasmus Villemoes87e747c2014-10-13 15:54:35 -07001790 if (strncasecmp(string, "default", 7) != 0) {
Taesoo Kim2bd50fb2015-03-21 19:08:30 -04001791 kfree(vol->iocharset);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001792 vol->iocharset = kstrdup(string,
1793 GFP_KERNEL);
1794 if (!vol->iocharset) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001795 pr_warn("CIFS: no memory for charset\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001796 goto cifs_parse_mount_err;
1797 }
1798 }
1799 /* if iocharset not set then load_nls_default
1800 * is used by caller
1801 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001802 cifs_dbg(FYI, "iocharset set to %s\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001803 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001804 case Opt_netbiosname:
1805 string = match_strdup(args);
1806 if (string == NULL)
1807 goto out_nomem;
1808
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001809 memset(vol->source_rfc1001_name, 0x20,
1810 RFC1001_NAME_LEN);
1811 /*
1812 * FIXME: are there cases in which a comma can
1813 * be valid in workstation netbios name (and
1814 * need special handling)?
1815 */
1816 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1817 /* don't ucase netbiosname for user */
1818 if (string[i] == 0)
1819 break;
1820 vol->source_rfc1001_name[i] = string[i];
1821 }
1822 /* The string has 16th byte zero still from
1823 * set at top of the function
1824 */
1825 if (i == RFC1001_NAME_LEN && string[i] != 0)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001826 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001827 break;
1828 case Opt_servern:
1829 /* servernetbiosname specified override *SMBSERVER */
1830 string = match_strdup(args);
1831 if (string == NULL)
1832 goto out_nomem;
1833
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001834 /* last byte, type, is 0x20 for servr type */
1835 memset(vol->target_rfc1001_name, 0x20,
1836 RFC1001_NAME_LEN_WITH_NULL);
1837
1838 /* BB are there cases in which a comma can be
1839 valid in this workstation netbios name
1840 (and need special handling)? */
1841
1842 /* user or mount helper must uppercase the
1843 netbios name */
1844 for (i = 0; i < 15; i++) {
1845 if (string[i] == 0)
1846 break;
1847 vol->target_rfc1001_name[i] = string[i];
1848 }
1849 /* The string has 16th byte zero still from
1850 set at top of the function */
1851 if (i == RFC1001_NAME_LEN && string[i] != 0)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001852 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001853 break;
1854 case Opt_ver:
1855 string = match_strdup(args);
1856 if (string == NULL)
1857 goto out_nomem;
1858
Rasmus Villemoes87e747c2014-10-13 15:54:35 -07001859 if (strncasecmp(string, "1", 1) == 0) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001860 /* This is the default */
1861 break;
1862 }
1863 /* For all other value, error */
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001864 pr_warn("CIFS: Invalid version specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001865 goto cifs_parse_mount_err;
Jeff Layton23db65f2012-05-15 12:20:51 -04001866 case Opt_vers:
1867 string = match_strdup(args);
1868 if (string == NULL)
1869 goto out_nomem;
1870
1871 if (cifs_parse_smb_version(string, vol) != 0)
1872 goto cifs_parse_mount_err;
1873 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001874 case Opt_sec:
1875 string = match_strdup(args);
1876 if (string == NULL)
1877 goto out_nomem;
1878
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001879 if (cifs_parse_security_flavors(string, vol) != 0)
1880 goto cifs_parse_mount_err;
1881 break;
Jeff Layton15b6a472012-05-16 07:50:15 -04001882 case Opt_cache:
1883 string = match_strdup(args);
1884 if (string == NULL)
1885 goto out_nomem;
1886
1887 if (cifs_parse_cache_flavor(string, vol) != 0)
1888 goto cifs_parse_mount_err;
1889 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001890 default:
Jeff Laytond8162552012-03-23 14:40:56 -04001891 /*
1892 * An option we don't recognize. Save it off for later
1893 * if we haven't already found one
1894 */
1895 if (!invalid)
1896 invalid = data;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001897 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001899 /* Free up any allocated string */
1900 kfree(string);
1901 string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001903
Jeff Laytond8162552012-03-23 14:40:56 -04001904 if (!sloppy && invalid) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001905 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
Jeff Laytond8162552012-03-23 14:40:56 -04001906 goto cifs_parse_mount_err;
1907 }
1908
Jeff Layton8a8798a2012-01-17 16:09:15 -05001909#ifndef CONFIG_KEYS
1910 /* Muliuser mounts require CONFIG_KEYS support */
1911 if (vol->multiuser) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001912 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001913 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001914 }
Jeff Layton8a8798a2012-01-17 16:09:15 -05001915#endif
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001916 if (!vol->UNC) {
Jeff Layton37d4f992013-05-24 07:40:05 -04001917 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001918 goto cifs_parse_mount_err;
1919 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001920
Jeff Layton62a1a432012-12-10 06:10:45 -05001921 /* make sure UNC has a share name */
1922 if (!strchr(vol->UNC + 3, '\\')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001923 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
Jeff Layton62a1a432012-12-10 06:10:45 -05001924 goto cifs_parse_mount_err;
1925 }
1926
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001927 if (!got_ip) {
1928 /* No ip= option specified? Try to get it from UNC */
1929 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1930 strlen(&vol->UNC[2]))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001931 pr_err("Unable to determine destination address.\n");
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001932 goto cifs_parse_mount_err;
1933 }
1934 }
1935
1936 /* set the port that we got earlier */
1937 cifs_set_port(dstaddr, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001939 if (uid_specified)
1940 vol->override_uid = override_uid;
1941 else if (override_uid == 1)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001942 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001943
1944 if (gid_specified)
1945 vol->override_gid = override_gid;
1946 else if (override_gid == 1)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001947 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001948
Sean Finneyb9468452011-04-11 13:19:32 +00001949 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001951
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001952out_nomem:
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001953 pr_warn("Could not allocate temporary buffer\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001954cifs_parse_mount_err:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001955 kfree(string);
Sean Finneyb9468452011-04-11 13:19:32 +00001956 kfree(mountdata_copy);
1957 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958}
1959
Ben Greear3eb9a882010-09-01 17:06:02 -07001960/** Returns true if srcaddr isn't specified and rhs isn't
1961 * specified, or if srcaddr is specified and
1962 * matches the IP address of the rhs argument.
1963 */
Jeff Layton45151482010-07-06 20:43:02 -04001964static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001965srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1966{
1967 switch (srcaddr->sa_family) {
1968 case AF_UNSPEC:
1969 return (rhs->sa_family == AF_UNSPEC);
1970 case AF_INET: {
1971 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1972 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1973 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1974 }
1975 case AF_INET6: {
1976 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
Nickolai Zeldoviche3e27752013-01-16 21:36:17 -05001977 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
Ben Greear3eb9a882010-09-01 17:06:02 -07001978 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1979 }
1980 default:
1981 WARN_ON(1);
1982 return false; /* don't expect to be here */
1983 }
1984}
1985
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001986/*
1987 * If no port is specified in addr structure, we try to match with 445 port
1988 * and if it fails - with 139 ports. It should be called only if address
1989 * families of server and addr are equal.
1990 */
1991static bool
1992match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1993{
Steve French6da97912011-03-13 18:55:55 +00001994 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001995
1996 switch (addr->sa_family) {
1997 case AF_INET:
1998 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1999 port = ((struct sockaddr_in *) addr)->sin_port;
2000 break;
2001 case AF_INET6:
2002 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2003 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2004 break;
2005 default:
2006 WARN_ON(1);
2007 return false;
2008 }
2009
2010 if (!port) {
2011 port = htons(CIFS_PORT);
2012 if (port == *sport)
2013 return true;
2014
2015 port = htons(RFC1001_PORT);
2016 }
2017
2018 return port == *sport;
2019}
Ben Greear3eb9a882010-09-01 17:06:02 -07002020
2021static bool
2022match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2023 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024{
Jeff Layton45151482010-07-06 20:43:02 -04002025 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002026 case AF_INET: {
2027 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2028 struct sockaddr_in *srv_addr4 =
2029 (struct sockaddr_in *)&server->dstaddr;
2030
2031 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04002032 return false;
Jeff Layton45151482010-07-06 20:43:02 -04002033 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002034 }
2035 case AF_INET6: {
2036 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2037 struct sockaddr_in6 *srv_addr6 =
2038 (struct sockaddr_in6 *)&server->dstaddr;
2039
Jeff Layton45151482010-07-06 20:43:02 -04002040 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002041 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04002042 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002043 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04002044 return false;
Jeff Layton45151482010-07-06 20:43:02 -04002045 break;
2046 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002047 default:
2048 WARN_ON(1);
2049 return false; /* don't expect to be here */
2050 }
Jeff Layton45151482010-07-06 20:43:02 -04002051
Ben Greear3eb9a882010-09-01 17:06:02 -07002052 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2053 return false;
2054
Jeff Layton45151482010-07-06 20:43:02 -04002055 return true;
2056}
2057
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002058static bool
2059match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2060{
Jeff Layton3f618222013-06-12 19:52:14 -05002061 /*
2062 * The select_sectype function should either return the vol->sectype
2063 * that was specified, or "Unspecified" if that sectype was not
2064 * compatible with the given NEGOTIATE request.
2065 */
2066 if (select_sectype(server, vol->sectype) == Unspecified)
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002067 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002068
Jeff Layton3f618222013-06-12 19:52:14 -05002069 /*
2070 * Now check if signing mode is acceptable. No need to check
2071 * global_secflags at this point since if MUST_SIGN is set then
2072 * the server->sign had better be too.
2073 */
Jeff Layton38d77c52013-05-26 07:01:00 -04002074 if (vol->sign && !server->sign)
2075 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002076
2077 return true;
2078}
2079
Jeff Layton9fa114f2012-11-26 11:09:57 -05002080static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002081{
Jeff Layton9fa114f2012-11-26 11:09:57 -05002082 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2083
Jeff Laytona0b3df52013-05-24 07:40:59 -04002084 if (vol->nosharesock)
2085 return 0;
2086
Jeff Layton23db65f2012-05-15 12:20:51 -04002087 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2088 return 0;
2089
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002090 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2091 return 0;
2092
2093 if (!match_address(server, addr,
2094 (struct sockaddr *)&vol->srcaddr))
2095 return 0;
2096
2097 if (!match_port(server, addr))
2098 return 0;
2099
2100 if (!match_security(server, vol))
2101 return 0;
2102
Steve Frenchadfeb3e2015-12-18 12:31:36 -06002103 if (server->echo_interval != vol->echo_interval)
2104 return 0;
2105
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002106 return 1;
2107}
2108
Jeff Layton45151482010-07-06 20:43:02 -04002109static struct TCP_Server_Info *
Jeff Layton9fa114f2012-11-26 11:09:57 -05002110cifs_find_tcp_session(struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04002111{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002112 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302114 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04002115 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Jeff Layton9fa114f2012-11-26 11:09:57 -05002116 if (!match_server(server, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002117 continue;
2118
Jeff Laytone7ddee92008-11-14 13:44:38 -05002119 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302120 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesf96637b2013-05-04 22:12:25 -05002121 cifs_dbg(FYI, "Existing tcp session with server found\n");
Jeff Laytone7ddee92008-11-14 13:44:38 -05002122 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302124 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 return NULL;
2126}
2127
Jeff Layton14fbf502008-11-14 13:53:46 -05002128static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05002129cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130{
Steve Frencha5c3e1c2014-09-16 04:16:19 -05002131 struct task_struct *task;
2132
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302133 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002134 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302135 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002136 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 }
Steve Frenchdea570e02008-05-06 22:05:51 +00002138
Rob Landleyf1d0c992011-01-22 15:44:05 -06002139 put_net(cifs_net_ns(server));
2140
Jeff Laytone7ddee92008-11-14 13:44:38 -05002141 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302142 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002143
Jeff Laytonc74093b2011-01-11 07:24:23 -05002144 cancel_delayed_work_sync(&server->echo);
2145
Jeff Laytone7ddee92008-11-14 13:44:38 -05002146 spin_lock(&GlobalMid_Lock);
2147 server->tcpStatus = CifsExiting;
2148 spin_unlock(&GlobalMid_Lock);
2149
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002150 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302151 cifs_fscache_release_client_cookie(server);
2152
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05002153 kfree(server->session_key.response);
2154 server->session_key.response = NULL;
2155 server->session_key.len = 0;
Steve Frencha5c3e1c2014-09-16 04:16:19 -05002156
2157 task = xchg(&server->tsk, NULL);
2158 if (task)
2159 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160}
2161
Jeff Layton63c038c2008-12-01 18:41:46 -05002162static struct TCP_Server_Info *
2163cifs_get_tcp_session(struct smb_vol *volume_info)
2164{
2165 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Layton63c038c2008-12-01 18:41:46 -05002166 int rc;
2167
Joe Perchesf96637b2013-05-04 22:12:25 -05002168 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
Jeff Layton63c038c2008-12-01 18:41:46 -05002169
2170 /* see if we already have a matching tcp_ses */
Jeff Layton9fa114f2012-11-26 11:09:57 -05002171 tcp_ses = cifs_find_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002172 if (tcp_ses)
2173 return tcp_ses;
2174
2175 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2176 if (!tcp_ses) {
2177 rc = -ENOMEM;
2178 goto out_err;
2179 }
2180
Jeff Layton23db65f2012-05-15 12:20:51 -04002181 tcp_ses->ops = volume_info->ops;
2182 tcp_ses->vals = volume_info->vals;
Rob Landleyf1d0c992011-01-22 15:44:05 -06002183 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05002184 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2185 if (IS_ERR(tcp_ses->hostname)) {
2186 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002187 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002188 }
2189
2190 tcp_ses->noblocksnd = volume_info->noblocksnd;
2191 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00002192 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +03002193 tcp_ses->in_flight = 0;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002194 tcp_ses->credits = 1;
Jeff Layton63c038c2008-12-01 18:41:46 -05002195 init_waitqueue_head(&tcp_ses->response_q);
2196 init_waitqueue_head(&tcp_ses->request_q);
2197 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2198 mutex_init(&tcp_ses->srv_mutex);
2199 memcpy(tcp_ses->workstation_RFC1001_name,
2200 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2201 memcpy(tcp_ses->server_RFC1001_name,
2202 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05002203 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05002204 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00002205 tcp_ses->lstrp = jiffies;
Jeff Layton58fa0152012-05-01 17:41:16 -04002206 spin_lock_init(&tcp_ses->req_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002207 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2208 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002209 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton9fa114f2012-11-26 11:09:57 -05002210 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2211 sizeof(tcp_ses->srcaddr));
2212 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2213 sizeof(tcp_ses->dstaddr));
Sachin Prabhu39552ea2014-05-13 00:48:12 +01002214#ifdef CONFIG_CIFS_SMB2
2215 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2216#endif
Jeff Layton63c038c2008-12-01 18:41:46 -05002217 /*
2218 * at this point we are the only ones with the pointer
2219 * to the struct since the kernel thread not created yet
2220 * no need to spinlock this init of tcpStatus or srv_count
2221 */
2222 tcp_ses->tcpStatus = CifsNew;
2223 ++tcp_ses->srv_count;
2224
Steve Frenchadfeb3e2015-12-18 12:31:36 -06002225 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2226 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2227 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2228 else
2229 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2230
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002231 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05002232 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002233 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002234 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002235 }
2236
2237 /*
2238 * since we're in a cifs function already, we know that
2239 * this will succeed. No need for try_module_get().
2240 */
2241 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04002242 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05002243 tcp_ses, "cifsd");
2244 if (IS_ERR(tcp_ses->tsk)) {
2245 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesf96637b2013-05-04 22:12:25 -05002246 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05002247 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002248 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002249 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00002250 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05002251
2252 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302253 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002254 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302255 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002256
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302257 cifs_fscache_get_client_cookie(tcp_ses);
2258
Jeff Laytonc74093b2011-01-11 07:24:23 -05002259 /* queue echo request delayed work */
Steve Frenchadfeb3e2015-12-18 12:31:36 -06002260 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002261
Jeff Layton63c038c2008-12-01 18:41:46 -05002262 return tcp_ses;
2263
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002264out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002265 cifs_crypto_shash_release(tcp_ses);
2266
Rob Landleyf1d0c992011-01-22 15:44:05 -06002267 put_net(cifs_net_ns(tcp_ses));
2268
Jeff Layton63c038c2008-12-01 18:41:46 -05002269out_err:
2270 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00002271 if (!IS_ERR(tcp_ses->hostname))
2272 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05002273 if (tcp_ses->ssocket)
2274 sock_release(tcp_ses->ssocket);
2275 kfree(tcp_ses);
2276 }
2277 return ERR_PTR(rc);
2278}
2279
Steve French96daf2b2011-05-27 04:34:02 +00002280static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002281{
Jeff Layton3f618222013-06-12 19:52:14 -05002282 if (vol->sectype != Unspecified &&
2283 vol->sectype != ses->sectype)
2284 return 0;
2285
2286 switch (ses->sectype) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002287 case Kerberos:
Eric W. Biederman64ed39d2013-02-06 02:30:39 -08002288 if (!uid_eq(vol->cred_uid, ses->cred_uid))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002289 return 0;
2290 break;
2291 default:
Jeff Layton04febab2012-01-17 16:09:15 -05002292 /* NULL username means anonymous session */
2293 if (ses->user_name == NULL) {
2294 if (!vol->nullauth)
2295 return 0;
2296 break;
2297 }
2298
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002299 /* anything else takes username/password */
Jeff Layton04febab2012-01-17 16:09:15 -05002300 if (strncmp(ses->user_name,
2301 vol->username ? vol->username : "",
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002302 CIFS_MAX_USERNAME_LEN))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002303 return 0;
Jeff Layton08b37d52014-05-23 06:53:10 -04002304 if ((vol->username && strlen(vol->username) != 0) &&
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002305 ses->password != NULL &&
2306 strncmp(ses->password,
2307 vol->password ? vol->password : "",
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002308 CIFS_MAX_PASSWORD_LEN))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002309 return 0;
2310 }
2311 return 1;
2312}
2313
Steve French96daf2b2011-05-27 04:34:02 +00002314static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04002315cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316{
Steve French96daf2b2011-05-27 04:34:02 +00002317 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302319 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002320 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002321 if (ses->status == CifsExiting)
2322 continue;
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002323 if (!match_session(ses, vol))
2324 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002325 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302326 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002327 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302329 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 return NULL;
2331}
2332
Jeff Layton14fbf502008-11-14 13:53:46 -05002333static void
Steve French96daf2b2011-05-27 04:34:02 +00002334cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002335{
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002336 unsigned int rc, xid;
Jeff Layton14fbf502008-11-14 13:53:46 -05002337 struct TCP_Server_Info *server = ses->server;
2338
Joe Perchesf96637b2013-05-04 22:12:25 -05002339 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002340
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302341 spin_lock(&cifs_tcp_ses_lock);
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002342 if (ses->status == CifsExiting) {
2343 spin_unlock(&cifs_tcp_ses_lock);
2344 return;
2345 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002346 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302347 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002348 return;
2349 }
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002350 if (ses->status == CifsGood)
2351 ses->status = CifsExiting;
2352 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002353
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002354 if (ses->status == CifsExiting && server->ops->logoff) {
2355 xid = get_xid();
2356 rc = server->ops->logoff(xid, ses);
2357 if (rc)
2358 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2359 __func__, rc);
2360 _free_xid(xid);
2361 }
2362
2363 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002364 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302365 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002366
Jeff Layton14fbf502008-11-14 13:53:46 -05002367 sesInfoFree(ses);
2368 cifs_put_tcp_session(server);
2369}
2370
Jeff Layton8a8798a2012-01-17 16:09:15 -05002371#ifdef CONFIG_KEYS
2372
Chen Gang057d6332013-07-19 09:01:36 +08002373/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2374#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
Jeff Layton8a8798a2012-01-17 16:09:15 -05002375
2376/* Populate username and pw fields from keyring if possible */
2377static int
2378cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2379{
2380 int rc = 0;
David Howells146aa8b2015-10-21 14:04:48 +01002381 const char *delim, *payload;
2382 char *desc;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002383 ssize_t len;
2384 struct key *key;
2385 struct TCP_Server_Info *server = ses->server;
2386 struct sockaddr_in *sa;
2387 struct sockaddr_in6 *sa6;
David Howells146aa8b2015-10-21 14:04:48 +01002388 const struct user_key_payload *upayload;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002389
2390 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2391 if (!desc)
2392 return -ENOMEM;
2393
2394 /* try to find an address key first */
2395 switch (server->dstaddr.ss_family) {
2396 case AF_INET:
2397 sa = (struct sockaddr_in *)&server->dstaddr;
2398 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2399 break;
2400 case AF_INET6:
2401 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2402 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2403 break;
2404 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05002405 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2406 server->dstaddr.ss_family);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002407 rc = -EINVAL;
2408 goto out_err;
2409 }
2410
Joe Perchesf96637b2013-05-04 22:12:25 -05002411 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002412 key = request_key(&key_type_logon, desc, "");
2413 if (IS_ERR(key)) {
2414 if (!ses->domainName) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002415 cifs_dbg(FYI, "domainName is NULL\n");
Jeff Layton8a8798a2012-01-17 16:09:15 -05002416 rc = PTR_ERR(key);
2417 goto out_err;
2418 }
2419
2420 /* didn't work, try to find a domain key */
2421 sprintf(desc, "cifs:d:%s", ses->domainName);
Joe Perchesf96637b2013-05-04 22:12:25 -05002422 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002423 key = request_key(&key_type_logon, desc, "");
2424 if (IS_ERR(key)) {
2425 rc = PTR_ERR(key);
2426 goto out_err;
2427 }
2428 }
2429
2430 down_read(&key->sem);
David Howells146aa8b2015-10-21 14:04:48 +01002431 upayload = user_key_payload(key);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002432 if (IS_ERR_OR_NULL(upayload)) {
Jeff Layton4edc53c2012-02-07 06:30:51 -05002433 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002434 goto out_key_put;
2435 }
2436
2437 /* find first : in payload */
David Howells146aa8b2015-10-21 14:04:48 +01002438 payload = upayload->data;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002439 delim = strnchr(payload, upayload->datalen, ':');
Joe Perchesf96637b2013-05-04 22:12:25 -05002440 cifs_dbg(FYI, "payload=%s\n", payload);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002441 if (!delim) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002442 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2443 upayload->datalen);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002444 rc = -EINVAL;
2445 goto out_key_put;
2446 }
2447
2448 len = delim - payload;
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002449 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002450 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2451 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002452 rc = -EINVAL;
2453 goto out_key_put;
2454 }
2455
2456 vol->username = kstrndup(payload, len, GFP_KERNEL);
2457 if (!vol->username) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002458 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2459 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002460 rc = -ENOMEM;
2461 goto out_key_put;
2462 }
Joe Perchesf96637b2013-05-04 22:12:25 -05002463 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002464
2465 len = key->datalen - (len + 1);
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002466 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002467 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002468 rc = -EINVAL;
2469 kfree(vol->username);
2470 vol->username = NULL;
2471 goto out_key_put;
2472 }
2473
2474 ++delim;
2475 vol->password = kstrndup(delim, len, GFP_KERNEL);
2476 if (!vol->password) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002477 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2478 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002479 rc = -ENOMEM;
2480 kfree(vol->username);
2481 vol->username = NULL;
2482 goto out_key_put;
2483 }
2484
2485out_key_put:
2486 up_read(&key->sem);
2487 key_put(key);
2488out_err:
2489 kfree(desc);
Joe Perchesf96637b2013-05-04 22:12:25 -05002490 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002491 return rc;
2492}
2493#else /* ! CONFIG_KEYS */
2494static inline int
2495cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2496 struct cifs_ses *ses __attribute__((unused)))
2497{
2498 return -ENOSYS;
2499}
2500#endif /* CONFIG_KEYS */
2501
Steve French96daf2b2011-05-27 04:34:02 +00002502static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002503cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2504{
Pavel Shilovsky286170a2012-05-25 10:43:58 +04002505 int rc = -ENOMEM;
2506 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002507 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002508 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2509 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002510
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002511 xid = get_xid();
Jeff Layton36988c72010-04-24 07:57:43 -04002512
Jeff Layton4ff67b72010-07-06 20:43:02 -04002513 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002514 if (ses) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002515 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2516 ses->status);
Jeff Layton36988c72010-04-24 07:57:43 -04002517
Jeff Layton36988c72010-04-24 07:57:43 -04002518 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002519 rc = cifs_negotiate_protocol(xid, ses);
2520 if (rc) {
2521 mutex_unlock(&ses->session_mutex);
2522 /* problem -- put our ses reference */
2523 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002524 free_xid(xid);
Jeff Layton198b5682010-04-24 07:57:48 -04002525 return ERR_PTR(rc);
2526 }
Jeff Layton36988c72010-04-24 07:57:43 -04002527 if (ses->need_reconnect) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002528 cifs_dbg(FYI, "Session needs reconnect\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002529 rc = cifs_setup_session(xid, ses,
2530 volume_info->local_nls);
2531 if (rc) {
2532 mutex_unlock(&ses->session_mutex);
2533 /* problem -- put our reference */
2534 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002535 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002536 return ERR_PTR(rc);
2537 }
2538 }
2539 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002540
2541 /* existing SMB ses has a server reference already */
2542 cifs_put_tcp_session(server);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002543 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002544 return ses;
2545 }
2546
Joe Perchesf96637b2013-05-04 22:12:25 -05002547 cifs_dbg(FYI, "Existing smb sess not found\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002548 ses = sesInfoAlloc();
2549 if (ses == NULL)
2550 goto get_ses_fail;
2551
2552 /* new SMB session uses our server ref */
2553 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002554 if (server->dstaddr.ss_family == AF_INET6)
2555 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002556 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002557 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002558
Steve French8727c8a2011-02-25 01:11:56 -06002559 if (volume_info->username) {
2560 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2561 if (!ses->user_name)
2562 goto get_ses_fail;
2563 }
Jeff Layton36988c72010-04-24 07:57:43 -04002564
2565 /* volume_info->password freed at unmount */
2566 if (volume_info->password) {
2567 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2568 if (!ses->password)
2569 goto get_ses_fail;
2570 }
2571 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002572 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2573 if (!ses->domainName)
2574 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002575 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002576 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002577 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002578
Jeff Layton28e11bd2013-05-26 07:01:00 -04002579 ses->sectype = volume_info->sectype;
2580 ses->sign = volume_info->sign;
Jeff Layton36988c72010-04-24 07:57:43 -04002581
2582 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002583 rc = cifs_negotiate_protocol(xid, ses);
2584 if (!rc)
2585 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002586 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002587 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002588 goto get_ses_fail;
2589
2590 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302591 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002592 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302593 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002594
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002595 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002596 return ses;
2597
2598get_ses_fail:
2599 sesInfoFree(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002600 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002601 return ERR_PTR(rc);
2602}
2603
Steve French96daf2b2011-05-27 04:34:02 +00002604static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002605{
2606 if (tcon->tidStatus == CifsExiting)
2607 return 0;
2608 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2609 return 0;
2610 return 1;
2611}
2612
Steve French96daf2b2011-05-27 04:34:02 +00002613static struct cifs_tcon *
2614cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615{
2616 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002617 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302619 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002620 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002621 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002622 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002623 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002624 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302625 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 return tcon;
2627 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302628 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 return NULL;
2630}
2631
Jeff Laytonf1987b42008-11-15 11:12:47 -05002632static void
Steve French96daf2b2011-05-27 04:34:02 +00002633cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002634{
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002635 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002636 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002637
Joe Perchesf96637b2013-05-04 22:12:25 -05002638 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302639 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002640 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302641 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002642 return;
2643 }
2644
2645 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302646 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002647
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002648 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002649 if (ses->server->ops->tree_disconnect)
2650 ses->server->ops->tree_disconnect(xid, tcon);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002651 _free_xid(xid);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002652
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302653 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002654 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002655 cifs_put_smb_ses(ses);
2656}
2657
Steve French96daf2b2011-05-27 04:34:02 +00002658static struct cifs_tcon *
2659cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002660{
2661 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002662 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002663
2664 tcon = cifs_find_tcon(ses, volume_info->UNC);
2665 if (tcon) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002666 cifs_dbg(FYI, "Found match on UNC path\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002667 /* existing tcon already has a reference */
2668 cifs_put_smb_ses(ses);
2669 if (tcon->seal != volume_info->seal)
Joe Perchesf96637b2013-05-04 22:12:25 -05002670 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002671 return tcon;
2672 }
2673
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002674 if (!ses->server->ops->tree_connect) {
2675 rc = -ENOSYS;
2676 goto out_fail;
2677 }
2678
Jeff Laytond00c28d2010-04-24 07:57:44 -04002679 tcon = tconInfoAlloc();
2680 if (tcon == NULL) {
2681 rc = -ENOMEM;
2682 goto out_fail;
2683 }
2684
2685 tcon->ses = ses;
2686 if (volume_info->password) {
2687 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2688 if (!tcon->password) {
2689 rc = -ENOMEM;
2690 goto out_fail;
2691 }
2692 }
2693
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002694 /*
2695 * BB Do we need to wrap session_mutex around this TCon call and Unix
2696 * SetFS as we do on SessSetup and reconnect?
2697 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002698 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002699 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2700 volume_info->local_nls);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002701 free_xid(xid);
Joe Perchesf96637b2013-05-04 22:12:25 -05002702 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002703 if (rc)
2704 goto out_fail;
2705
2706 if (volume_info->nodfs) {
2707 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002708 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002709 }
2710 tcon->seal = volume_info->seal;
Steve Frenchb618f002015-11-03 09:15:03 -06002711 tcon->use_persistent = false;
2712 /* check if SMB2 or later, CIFS does not support persistent handles */
2713 if (volume_info->persistent) {
2714 if (ses->server->vals->protocol_id == 0) {
2715 cifs_dbg(VFS,
2716 "SMB3 or later required for persistent handles\n");
2717 rc = -EOPNOTSUPP;
2718 goto out_fail;
Steve French592fafe2015-11-03 10:08:53 -06002719#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06002720 } else if (ses->server->capabilities &
2721 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2722 tcon->use_persistent = true;
2723 else /* persistent handles requested but not supported */ {
2724 cifs_dbg(VFS,
2725 "Persistent handles not supported on share\n");
2726 rc = -EOPNOTSUPP;
2727 goto out_fail;
Steve French592fafe2015-11-03 10:08:53 -06002728#endif /* CONFIG_CIFS_SMB2 */
Steve Frenchb618f002015-11-03 09:15:03 -06002729 }
Steve French592fafe2015-11-03 10:08:53 -06002730#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06002731 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2732 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2733 && (volume_info->nopersistent == false)) {
2734 cifs_dbg(FYI, "enabling persistent handles\n");
2735 tcon->use_persistent = true;
Steve French592fafe2015-11-03 10:08:53 -06002736#endif /* CONFIG_CIFS_SMB2 */
2737 } else if (volume_info->resilient) {
2738 if (ses->server->vals->protocol_id == 0) {
2739 cifs_dbg(VFS,
2740 "SMB2.1 or later required for resilient handles\n");
2741 rc = -EOPNOTSUPP;
2742 goto out_fail;
2743 }
2744 tcon->use_resilient = true;
Steve Frenchb618f002015-11-03 09:15:03 -06002745 }
2746
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002747 /*
2748 * We can have only one retry value for a connection to a share so for
2749 * resources mounted more than once to the same server share the last
2750 * value passed in for the retry flag is used.
2751 */
Jeff Laytond00c28d2010-04-24 07:57:44 -04002752 tcon->retry = volume_info->retry;
2753 tcon->nocase = volume_info->nocase;
2754 tcon->local_lease = volume_info->local_lease;
Pavel Shilovsky233839b2012-09-19 06:22:45 -07002755 INIT_LIST_HEAD(&tcon->pending_opens);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002756
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302757 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002758 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302759 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002760
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302761 cifs_fscache_get_super_cookie(tcon);
2762
Jeff Laytond00c28d2010-04-24 07:57:44 -04002763 return tcon;
2764
2765out_fail:
2766 tconInfoFree(tcon);
2767 return ERR_PTR(rc);
2768}
2769
Jeff Layton9d002df2010-10-06 19:51:11 -04002770void
2771cifs_put_tlink(struct tcon_link *tlink)
2772{
2773 if (!tlink || IS_ERR(tlink))
2774 return;
2775
2776 if (!atomic_dec_and_test(&tlink->tl_count) ||
2777 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2778 tlink->tl_time = jiffies;
2779 return;
2780 }
2781
2782 if (!IS_ERR(tlink_tcon(tlink)))
2783 cifs_put_tcon(tlink_tcon(tlink));
2784 kfree(tlink);
2785 return;
2786}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002787
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002788static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002789cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2790{
2791 return cifs_sb->master_tlink;
2792}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002793
2794static int
2795compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2796{
2797 struct cifs_sb_info *old = CIFS_SB(sb);
2798 struct cifs_sb_info *new = mnt_data->cifs_sb;
2799
2800 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2801 return 0;
2802
2803 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2804 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2805 return 0;
2806
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002807 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002808 * We want to share sb only if we don't specify an r/wsize or
2809 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002810 */
2811 if (new->wsize && new->wsize < old->wsize)
2812 return 0;
2813
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002814 if (new->rsize && new->rsize < old->rsize)
2815 return 0;
2816
Eric W. Biederman1f682332013-02-06 01:20:20 -08002817 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002818 return 0;
2819
2820 if (old->mnt_file_mode != new->mnt_file_mode ||
2821 old->mnt_dir_mode != new->mnt_dir_mode)
2822 return 0;
2823
2824 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2825 return 0;
2826
2827 if (old->actimeo != new->actimeo)
2828 return 0;
2829
2830 return 1;
2831}
2832
2833int
2834cifs_match_super(struct super_block *sb, void *data)
2835{
2836 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2837 struct smb_vol *volume_info;
2838 struct cifs_sb_info *cifs_sb;
2839 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002840 struct cifs_ses *ses;
2841 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002842 struct tcon_link *tlink;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002843 int rc = 0;
2844
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002845 spin_lock(&cifs_tcp_ses_lock);
2846 cifs_sb = CIFS_SB(sb);
2847 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2848 if (IS_ERR(tlink)) {
2849 spin_unlock(&cifs_tcp_ses_lock);
2850 return rc;
2851 }
2852 tcon = tlink_tcon(tlink);
2853 ses = tcon->ses;
2854 tcp_srv = ses->server;
2855
2856 volume_info = mnt_data->vol;
2857
Jeff Layton9fa114f2012-11-26 11:09:57 -05002858 if (!match_server(tcp_srv, volume_info) ||
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002859 !match_session(ses, volume_info) ||
2860 !match_tcon(tcon, volume_info->UNC)) {
2861 rc = 0;
2862 goto out;
2863 }
2864
2865 rc = compare_mount_options(sb, mnt_data);
2866out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002867 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002868 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002869 return rc;
2870}
2871
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002873get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002874 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2875 struct dfs_info3_param **referrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876{
2877 char *temp_unc;
2878 int rc = 0;
2879
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002880 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002881 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002883 *num_referrals = 0;
2884 *referrals = NULL;
2885
2886 if (ses->ipc_tid == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 temp_unc = kmalloc(2 /* for slashes */ +
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002888 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2889 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 if (temp_unc == NULL)
2891 return -ENOMEM;
2892 temp_unc[0] = '\\';
2893 temp_unc[1] = '\\';
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002894 strcpy(temp_unc + 2, ses->serverName);
2895 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2896 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2897 nls_codepage);
Joe Perchesf96637b2013-05-04 22:12:25 -05002898 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 kfree(temp_unc);
2900 }
2901 if (rc == 0)
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002902 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2903 referrals, num_referrals,
2904 nls_codepage, remap);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002905 /*
2906 * BB - map targetUNCs to dfs_info3 structures, here or in
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002907 * ses->server->ops->get_dfs_refer.
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002908 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909
2910 return rc;
2911}
2912
Jeff Layton09e50d52008-07-23 10:11:19 -04002913#ifdef CONFIG_DEBUG_LOCK_ALLOC
2914static struct lock_class_key cifs_key[2];
2915static struct lock_class_key cifs_slock_key[2];
2916
2917static inline void
2918cifs_reclassify_socket4(struct socket *sock)
2919{
2920 struct sock *sk = sock->sk;
2921 BUG_ON(sock_owned_by_user(sk));
2922 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2923 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2924}
2925
2926static inline void
2927cifs_reclassify_socket6(struct socket *sock)
2928{
2929 struct sock *sk = sock->sk;
2930 BUG_ON(sock_owned_by_user(sk));
2931 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2932 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2933}
2934#else
2935static inline void
2936cifs_reclassify_socket4(struct socket *sock)
2937{
2938}
2939
2940static inline void
2941cifs_reclassify_socket6(struct socket *sock)
2942{
2943}
2944#endif
2945
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002947static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948{
Steve French50c2f752007-07-13 00:33:32 +00002949 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950
Steve French50c2f752007-07-13 00:33:32 +00002951 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952 /* mask a nibble at a time and encode */
2953 target[j] = 'A' + (0x0F & (source[i] >> 4));
2954 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002955 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957
2958}
2959
Ben Greear3eb9a882010-09-01 17:06:02 -07002960static int
2961bind_socket(struct TCP_Server_Info *server)
2962{
2963 int rc = 0;
2964 if (server->srcaddr.ss_family != AF_UNSPEC) {
2965 /* Bind to the specified local IP address */
2966 struct socket *socket = server->ssocket;
2967 rc = socket->ops->bind(socket,
2968 (struct sockaddr *) &server->srcaddr,
2969 sizeof(server->srcaddr));
2970 if (rc < 0) {
2971 struct sockaddr_in *saddr4;
2972 struct sockaddr_in6 *saddr6;
2973 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2974 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2975 if (saddr6->sin6_family == AF_INET6)
Joe Perchesf96637b2013-05-04 22:12:25 -05002976 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2977 &saddr6->sin6_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002978 else
Joe Perchesf96637b2013-05-04 22:12:25 -05002979 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2980 &saddr4->sin_addr.s_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002981 }
2982 }
2983 return rc;
2984}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985
2986static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002987ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988{
2989 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002990 /*
2991 * some servers require RFC1001 sessinit before sending
2992 * negprot - BB check reconnection in case where second
2993 * sessinit is sent but no second negprot
2994 */
2995 struct rfc1002_session_packet *ses_init_buf;
2996 struct smb_hdr *smb_buf;
2997 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2998 GFP_KERNEL);
2999 if (ses_init_buf) {
3000 ses_init_buf->trailer.session_req.called_len = 32;
3001
3002 if (server->server_RFC1001_name &&
3003 server->server_RFC1001_name[0] != 0)
3004 rfc1002mangle(ses_init_buf->trailer.
3005 session_req.called_name,
3006 server->server_RFC1001_name,
3007 RFC1001_NAME_LEN_WITH_NULL);
3008 else
3009 rfc1002mangle(ses_init_buf->trailer.
3010 session_req.called_name,
3011 DEFAULT_CIFS_CALLED_NAME,
3012 RFC1001_NAME_LEN_WITH_NULL);
3013
3014 ses_init_buf->trailer.session_req.calling_len = 32;
3015
3016 /*
3017 * calling name ends in null (byte 16) from old smb
3018 * convention.
3019 */
Steve Frenchc85c35f2015-03-27 01:15:02 -05003020 if (server->workstation_RFC1001_name[0] != 0)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003021 rfc1002mangle(ses_init_buf->trailer.
3022 session_req.calling_name,
3023 server->workstation_RFC1001_name,
3024 RFC1001_NAME_LEN_WITH_NULL);
3025 else
3026 rfc1002mangle(ses_init_buf->trailer.
3027 session_req.calling_name,
3028 "LINUX_CIFS_CLNT",
3029 RFC1001_NAME_LEN_WITH_NULL);
3030
3031 ses_init_buf->trailer.session_req.scope1 = 0;
3032 ses_init_buf->trailer.session_req.scope2 = 0;
3033 smb_buf = (struct smb_hdr *)ses_init_buf;
3034
3035 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003036 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003037 rc = smb_send(server, smb_buf, 0x44);
3038 kfree(ses_init_buf);
3039 /*
3040 * RFC1001 layer in at least one server
3041 * requires very short break before negprot
3042 * presumably because not expecting negprot
3043 * to follow so fast. This is a simple
3044 * solution that works without
3045 * complicating the code and causes no
3046 * significant slowing down on mount
3047 * for everyone else
3048 */
3049 usleep_range(1000, 2000);
3050 }
3051 /*
3052 * else the negprot may still work without this
3053 * even though malloc failed
3054 */
3055
3056 return rc;
3057}
3058
3059static int
3060generic_ip_connect(struct TCP_Server_Info *server)
3061{
3062 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00003063 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003064 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003065 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003066 struct sockaddr *saddr;
3067
3068 saddr = (struct sockaddr *) &server->dstaddr;
3069
3070 if (server->dstaddr.ss_family == AF_INET6) {
3071 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3072 slen = sizeof(struct sockaddr_in6);
3073 sfamily = AF_INET6;
3074 } else {
3075 sport = ((struct sockaddr_in *) saddr)->sin_port;
3076 slen = sizeof(struct sockaddr_in);
3077 sfamily = AF_INET;
3078 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003079
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003080 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06003081 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3082 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003084 cifs_dbg(VFS, "Error %d creating socket\n", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003085 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003088
3089 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesf96637b2013-05-04 22:12:25 -05003090 cifs_dbg(FYI, "Socket created\n");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003091 server->ssocket = socket;
3092 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003093 if (sfamily == AF_INET6)
3094 cifs_reclassify_socket6(socket);
3095 else
3096 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 }
3098
Ben Greear3eb9a882010-09-01 17:06:02 -07003099 rc = bind_socket(server);
3100 if (rc < 0)
3101 return rc;
3102
Jeff Laytond5c56052008-12-01 18:42:33 -05003103 /*
3104 * Eventually check for other socket options to change from
3105 * the default. sock_setsockopt not used because it expects
3106 * user space buffer
3107 */
3108 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00003109 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00003110
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003111 /* make the bufsizes depend on wsize/rsize and max requests */
3112 if (server->noautotune) {
3113 if (socket->sk->sk_sndbuf < (200 * 1024))
3114 socket->sk->sk_sndbuf = 200 * 1024;
3115 if (socket->sk->sk_rcvbuf < (140 * 1024))
3116 socket->sk->sk_rcvbuf = 140 * 1024;
3117 }
3118
Steve French6a5fa2362010-01-01 01:28:43 +00003119 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003120 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00003121 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3122 (char *)&val, sizeof(val));
3123 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003124 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3125 rc);
Steve French6a5fa2362010-01-01 01:28:43 +00003126 }
3127
Joe Perchesf96637b2013-05-04 22:12:25 -05003128 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003129 socket->sk->sk_sndbuf,
3130 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3131
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003132 rc = socket->ops->connect(socket, saddr, slen, 0);
3133 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003134 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003135 sock_release(socket);
3136 server->ssocket = NULL;
3137 return rc;
3138 }
3139
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003140 if (sport == htons(RFC1001_PORT))
3141 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003142
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143 return rc;
3144}
3145
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003146static int
3147ip_connect(struct TCP_Server_Info *server)
3148{
Steve French6da97912011-03-13 18:55:55 +00003149 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003150 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3151 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3152
3153 if (server->dstaddr.ss_family == AF_INET6)
3154 sport = &addr6->sin6_port;
3155 else
3156 sport = &addr->sin_port;
3157
3158 if (*sport == 0) {
3159 int rc;
3160
3161 /* try with 445 port at first */
3162 *sport = htons(CIFS_PORT);
3163
3164 rc = generic_ip_connect(server);
3165 if (rc >= 0)
3166 return rc;
3167
3168 /* if it failed, try with 139 port */
3169 *sport = htons(RFC1001_PORT);
3170 }
3171
3172 return generic_ip_connect(server);
3173}
3174
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003175void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003176 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003177{
3178 /* if we are reconnecting then should we check to see if
3179 * any requested capabilities changed locally e.g. via
3180 * remount but we can not do much about it here
3181 * if they have (even if we could detect it by the following)
3182 * Perhaps we could add a backpointer to array of sb from tcon
3183 * or if we change to make all sb to same share the same
3184 * sb as NFS - then we only have one backpointer to sb.
3185 * What if we wanted to mount the server share twice once with
3186 * and once without posixacls or posix paths? */
3187 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003188
Steve Frenchc18c8422007-07-18 23:21:09 +00003189 if (vol_info && vol_info->no_linux_ext) {
3190 tcon->fsUnixInfo.Capability = 0;
3191 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesf96637b2013-05-04 22:12:25 -05003192 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003193 return;
3194 } else if (vol_info)
3195 tcon->unix_ext = 1; /* Unix Extensions supported */
3196
3197 if (tcon->unix_ext == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003198 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003199 return;
3200 }
Steve French50c2f752007-07-13 00:33:32 +00003201
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003202 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003203 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Joe Perchesf96637b2013-05-04 22:12:25 -05003204 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
Steve French8af18972007-02-14 04:42:51 +00003205 /* check for reconnect case in which we do not
3206 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003207 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003208 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003209 originally at mount time */
3210 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3211 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003212 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3213 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003214 cifs_dbg(VFS, "POSIXPATH support change\n");
Steve French8af18972007-02-14 04:42:51 +00003215 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003216 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003217 cifs_dbg(VFS, "possible reconnect error\n");
3218 cifs_dbg(VFS, "server disabled POSIX path support\n");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003219 }
Steve French8af18972007-02-14 04:42:51 +00003220 }
Steve French50c2f752007-07-13 00:33:32 +00003221
Steve French6848b732011-05-26 18:38:54 +00003222 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003223 cifs_dbg(VFS, "per-share encryption not supported yet\n");
Steve French6848b732011-05-26 18:38:54 +00003224
Steve French8af18972007-02-14 04:42:51 +00003225 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00003226 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003227 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003228 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003229 cifs_dbg(FYI, "negotiated posix acl support\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003230 if (cifs_sb)
3231 cifs_sb->mnt_cifs_flags |=
3232 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003233 }
3234
Steve French75865f8c2007-06-24 18:30:48 +00003235 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003236 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003237 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003238 cifs_dbg(FYI, "negotiate posix pathnames\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003239 if (cifs_sb)
3240 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003241 CIFS_MOUNT_POSIX_PATHS;
3242 }
Steve French50c2f752007-07-13 00:33:32 +00003243
Joe Perchesf96637b2013-05-04 22:12:25 -05003244 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003245#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00003246 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003247 cifs_dbg(FYI, "FCNTL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003248 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003249 cifs_dbg(FYI, "EXTATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003250 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003251 cifs_dbg(FYI, "POSIX path cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003252 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003253 cifs_dbg(FYI, "XATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003254 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003255 cifs_dbg(FYI, "POSIX ACL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003256 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003257 cifs_dbg(FYI, "very large read cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003258 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003259 cifs_dbg(FYI, "very large write cap\n");
Steve French6848b732011-05-26 18:38:54 +00003260 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003261 cifs_dbg(FYI, "transport encryption cap\n");
Steve French6848b732011-05-26 18:38:54 +00003262 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003263 cifs_dbg(FYI, "mandatory transport encryption cap\n");
Steve French8af18972007-02-14 04:42:51 +00003264#endif /* CIFS_DEBUG2 */
3265 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003266 if (vol_info == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003267 cifs_dbg(FYI, "resetting capabilities failed\n");
Steve French442aa312007-09-24 20:25:46 +00003268 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05003269 cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
Steve French5a44b312007-09-20 15:16:24 +00003270
Steve French8af18972007-02-14 04:42:51 +00003271 }
3272 }
3273}
3274
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003275void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3276 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003277{
Jeff Layton2de970f2010-10-06 19:51:12 -04003278 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3279
Al Viro2ced6f62011-06-17 09:20:04 -04003280 spin_lock_init(&cifs_sb->tlink_tree_lock);
3281 cifs_sb->tlink_tree = RB_ROOT;
3282
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003283 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003284 * Temporarily set r/wsize for matching superblock. If we end up using
3285 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003286 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003287 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003288 cifs_sb->wsize = pvolume_info->wsize;
3289
Steve French3b795212008-11-13 19:45:32 +00003290 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3291 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3292 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3293 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -05003294 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3295 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003296
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303297 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003298 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303299
Steve French3b795212008-11-13 19:45:32 +00003300 if (pvolume_info->noperm)
3301 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3302 if (pvolume_info->setuids)
3303 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3304 if (pvolume_info->server_ino)
3305 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3306 if (pvolume_info->remap)
Steve French2baa2682014-09-27 02:19:01 -05003307 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3308 if (pvolume_info->sfu_remap)
Steve French3b795212008-11-13 19:45:32 +00003309 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3310 if (pvolume_info->no_xattr)
3311 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3312 if (pvolume_info->sfu_emul)
3313 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3314 if (pvolume_info->nobrl)
3315 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003316 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003318 if (pvolume_info->mand_lock)
3319 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003320 if (pvolume_info->rwpidforward)
3321 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003322 if (pvolume_info->cifs_acl)
3323 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003324 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003325 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003326 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3327 }
3328 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003329 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003330 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3331 }
Steve French3b795212008-11-13 19:45:32 +00003332 if (pvolume_info->override_uid)
3333 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3334 if (pvolume_info->override_gid)
3335 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3336 if (pvolume_info->dynperm)
3337 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303338 if (pvolume_info->fsc)
3339 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003340 if (pvolume_info->multiuser)
3341 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3342 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003343 if (pvolume_info->strict_io)
3344 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003345 if (pvolume_info->direct_io) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003346 cifs_dbg(FYI, "mounting share using direct i/o\n");
Steve French3b795212008-11-13 19:45:32 +00003347 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3348 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003349 if (pvolume_info->mfsymlinks) {
3350 if (pvolume_info->sfu_emul) {
Steve Frenchdb8b6312014-09-22 05:13:55 -05003351 /*
3352 * Our SFU ("Services for Unix" emulation does not allow
3353 * creating symlinks but does allow reading existing SFU
3354 * symlinks (it does allow both creating and reading SFU
3355 * style mknod and FIFOs though). When "mfsymlinks" and
3356 * "sfu" are both enabled at the same time, it allows
3357 * reading both types of symlinks, but will only create
3358 * them with mfsymlinks format. This allows better
3359 * Apple compatibility (probably better for Samba too)
3360 * while still recognizing old Windows style symlinks.
3361 */
3362 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003363 }
Steve Frenchdb8b6312014-09-22 05:13:55 -05003364 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003365 }
Steve French3b795212008-11-13 19:45:32 +00003366
3367 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesf96637b2013-05-04 22:12:25 -05003368 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003369}
3370
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003371static void
3372cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003373{
Sean Finneyb9468452011-04-11 13:19:32 +00003374 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003375 kzfree(volume_info->password);
Jesper Juhl95c75452011-08-27 18:58:34 +02003376 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003377 kfree(volume_info->domainname);
3378 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003379 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003380}
3381
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003382void
3383cifs_cleanup_volume_info(struct smb_vol *volume_info)
3384{
3385 if (!volume_info)
3386 return;
3387 cleanup_volume_info_contents(volume_info);
3388 kfree(volume_info);
3389}
3390
3391
Steve French2d6d5892009-04-09 00:36:44 +00003392#ifdef CONFIG_CIFS_DFS_UPCALL
Steve French6d3ea7e2012-11-28 22:34:41 -06003393/*
3394 * cifs_build_path_to_root returns full path to root when we do not have an
3395 * exiting connection (tcon)
3396 */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003397static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003398build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003399 const struct cifs_sb_info *cifs_sb)
3400{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003401 char *full_path, *pos;
Jeff Layton839db3d2012-12-10 06:10:45 -05003402 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003403 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003404
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003405 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003406 if (full_path == NULL)
3407 return ERR_PTR(-ENOMEM);
3408
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003409 strncpy(full_path, vol->UNC, unc_len);
3410 pos = full_path + unc_len;
3411
3412 if (pplen) {
Jeff Layton1fc29ba2013-05-31 10:00:18 -04003413 *pos = CIFS_DIR_SEP(cifs_sb);
3414 strncpy(pos + 1, vol->prepath, pplen);
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003415 pos += pplen;
3416 }
3417
3418 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003419 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05003420 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003421 return full_path;
3422}
Sean Finneydd613942011-04-11 13:19:30 +00003423
3424/*
3425 * Perform a dfs referral query for a share and (optionally) prefix
3426 *
Sean Finney046462a2011-04-11 13:19:33 +00003427 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3428 * to a string containing updated options for the submount. Otherwise it
3429 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003430 *
3431 * Returns the rc from get_dfs_path to the caller, which can be used to
3432 * determine whether there were referrals.
3433 */
3434static int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003435expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
Sean Finneydd613942011-04-11 13:19:30 +00003436 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003437 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003438{
3439 int rc;
3440 unsigned int num_referrals = 0;
3441 struct dfs_info3_param *referrals = NULL;
3442 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3443
3444 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3445 if (IS_ERR(full_path))
3446 return PTR_ERR(full_path);
3447
3448 /* For DFS paths, skip the first '\' of the UNC */
3449 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3450
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003451 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05003452 &num_referrals, &referrals, cifs_remap(cifs_sb));
Sean Finneydd613942011-04-11 13:19:30 +00003453
3454 if (!rc && num_referrals > 0) {
3455 char *fake_devname = NULL;
3456
3457 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3458 full_path + 1, referrals,
3459 &fake_devname);
3460
3461 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003462
Sean Finneydd613942011-04-11 13:19:30 +00003463 if (IS_ERR(mdata)) {
3464 rc = PTR_ERR(mdata);
3465 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003466 } else {
3467 cleanup_volume_info_contents(volume_info);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003468 rc = cifs_setup_volume_info(volume_info, mdata,
3469 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003470 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003471 kfree(fake_devname);
3472 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003473 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003474 }
3475 kfree(full_path);
3476 return rc;
3477}
Steve French2d6d5892009-04-09 00:36:44 +00003478#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003479
Jeff Layton04db79b2011-07-06 08:10:38 -04003480static int
3481cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3482 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003484 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003485
Jeff Layton04db79b2011-07-06 08:10:38 -04003486 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3487 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488
Jeff Layton7586b762008-12-01 18:41:49 -05003489 if (volume_info->nullauth) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003490 cifs_dbg(FYI, "Anonymous login\n");
Jeff Layton04febab2012-01-17 16:09:15 -05003491 kfree(volume_info->username);
3492 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003493 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494 /* BB fixme parse for domain name here */
Joe Perchesf96637b2013-05-04 22:12:25 -05003495 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05003497 cifs_dbg(VFS, "No username specified\n");
Steve French50c2f752007-07-13 00:33:32 +00003498 /* In userspace mount helper we can get user name from alternate
3499 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003500 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501 }
3502
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003504 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003505 /* load_nls_default cannot return null */
3506 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003508 volume_info->local_nls = load_nls(volume_info->iocharset);
3509 if (volume_info->local_nls == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003510 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003511 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003512 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513 }
3514 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003515
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003516 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003517}
3518
3519struct smb_vol *
3520cifs_get_volume_info(char *mount_data, const char *devname)
3521{
3522 int rc;
3523 struct smb_vol *volume_info;
3524
Jeff Layton6ee95422012-11-26 11:09:57 -05003525 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003526 if (!volume_info)
3527 return ERR_PTR(-ENOMEM);
3528
3529 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3530 if (rc) {
3531 cifs_cleanup_volume_info(volume_info);
3532 volume_info = ERR_PTR(rc);
3533 }
3534
3535 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003536}
3537
3538int
Al Viro2c6292a2011-06-17 09:05:48 -04003539cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003540{
Jeff Layton1daaae82012-03-21 06:30:40 -04003541 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003542 unsigned int xid;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003543 struct cifs_ses *ses;
Steve French96daf2b2011-05-27 04:34:02 +00003544 struct cifs_tcon *tcon;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003545 struct TCP_Server_Info *server;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003546 char *full_path;
3547 struct tcon_link *tlink;
3548#ifdef CONFIG_CIFS_DFS_UPCALL
3549 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003550#endif
Al Virodd854462011-06-17 08:24:42 -04003551
Christoph Hellwigb4caecd2015-01-14 10:42:32 +01003552 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
Al Virodd854462011-06-17 08:24:42 -04003553 if (rc)
3554 return rc;
3555
Jeff Layton20547492011-07-09 12:21:07 -04003556#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003557try_mount_again:
3558 /* cleanup activities if we're chasing a referral */
3559 if (referral_walks_count) {
3560 if (tcon)
3561 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003562 else if (ses)
3563 cifs_put_smb_ses(ses);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003564
Sachin Prabhu1dfd18d2015-06-16 16:36:17 +01003565 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3566
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003567 free_xid(xid);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003568 }
3569#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003570 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003571 tcon = NULL;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003572 ses = NULL;
3573 server = NULL;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003574 full_path = NULL;
3575 tlink = NULL;
3576
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003577 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578
Jeff Layton63c038c2008-12-01 18:41:46 -05003579 /* get a reference to a tcp session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003580 server = cifs_get_tcp_session(volume_info);
3581 if (IS_ERR(server)) {
3582 rc = PTR_ERR(server);
Al Virodd854462011-06-17 08:24:42 -04003583 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003584 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585 }
3586
Jeff Layton36988c72010-04-24 07:57:43 -04003587 /* get a reference to a SMB session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003588 ses = cifs_get_smb_ses(server, volume_info);
3589 if (IS_ERR(ses)) {
3590 rc = PTR_ERR(ses);
3591 ses = NULL;
Jeff Layton36988c72010-04-24 07:57:43 -04003592 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 }
Steve French50c2f752007-07-13 00:33:32 +00003594
Steve French592fafe2015-11-03 10:08:53 -06003595#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06003596 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3597 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3598 cifs_dbg(VFS, "persistent handles not supported by server\n");
3599 rc = -EOPNOTSUPP;
3600 goto mount_fail_check;
3601 }
Steve French592fafe2015-11-03 10:08:53 -06003602#endif /* CONFIG_CIFS_SMB2*/
3603
Jeff Laytond00c28d2010-04-24 07:57:44 -04003604 /* search for existing tcon to this server share */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003605 tcon = cifs_get_tcon(ses, volume_info);
Jeff Laytond00c28d2010-04-24 07:57:44 -04003606 if (IS_ERR(tcon)) {
3607 rc = PTR_ERR(tcon);
3608 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003609 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003610 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003611
Steve French6848b732011-05-26 18:38:54 +00003612 /* tell server which Unix caps we support */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003613 if (cap_unix(tcon->ses)) {
Steve French6848b732011-05-26 18:38:54 +00003614 /* reset of caps checks mount to see if unix extensions
3615 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003616 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003617 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3618 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3619 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3620 rc = -EACCES;
3621 goto mount_fail_check;
3622 }
3623 } else
3624 tcon->unix_ext = 0; /* server does not support them */
3625
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003626 /* do not care if a following call succeed - informational */
3627 if (!tcon->ipc && server->ops->qfs_tcon)
3628 server->ops->qfs_tcon(xid, tcon);
Steve Frenchd82c2df2008-11-15 00:07:26 +00003629
Pavel Shilovsky24985c52012-09-18 16:20:28 -07003630 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3631 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003632
Jeff Layton66bfaad2011-10-19 15:30:35 -04003633 /* tune readahead according to rsize */
Jeff Layton8f714652012-05-01 17:41:49 -04003634 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003635
Igor Mammedove4cce942009-02-10 14:10:26 +03003636remote_path_check:
3637#ifdef CONFIG_CIFS_DFS_UPCALL
3638 /*
3639 * Perform an unconditional check for whether there are DFS
3640 * referrals for this path without prefix, to provide support
3641 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003642 * with PATH_NOT_COVERED to requests that include the prefix.
3643 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003644 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003645 if (referral_walks_count == 0) {
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003646 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3647 false);
Steve Frencheeac8042006-01-13 21:34:58 -08003648 if (!refrc) {
Steve French4523cc32007-04-30 20:13:06 +00003649 referral_walks_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650 goto try_mount_again;
3651 }
3652 }
3653#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003654
Steve Frenchf87d39d2011-05-27 03:50:55 +00003655 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656 if (!rc && tcon) {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003657 if (!server->ops->is_path_accessible) {
3658 rc = -ENOSYS;
3659 goto mount_fail_check;
3660 }
Steve French6d3ea7e2012-11-28 22:34:41 -06003661 /*
3662 * cifs_build_path_to_root works only when we have a valid tcon
3663 */
3664 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003665 if (full_path == NULL) {
3666 rc = -ENOMEM;
3667 goto mount_fail_check;
3668 }
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003669 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3670 full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003671 if (rc != 0 && rc != -EREMOTE) {
3672 kfree(full_path);
3673 goto mount_fail_check;
3674 }
3675 kfree(full_path);
3676 }
3677
3678 /* get referral if needed */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003679 if (rc == -EREMOTE) {
3680#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003681 if (referral_walks_count > MAX_NESTED_LINKS) {
3682 /*
3683 * BB: when we implement proper loop detection,
3684 * we will remove this check. But now we need it
3685 * to prevent an indefinite loop if 'DFS tree' is
3686 * misconfigured (i.e. has loops).
3687 */
3688 rc = -ELOOP;
3689 goto mount_fail_check;
3690 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003691
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003692 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003693
Sean Finneydd613942011-04-11 13:19:30 +00003694 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003695 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003696 goto try_mount_again;
3697 }
Sean Finneydd613942011-04-11 13:19:30 +00003698 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003699#else /* No DFS support, return error on mount */
3700 rc = -EOPNOTSUPP;
3701#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003702 }
3703
Jeff Layton9d002df2010-10-06 19:51:11 -04003704 if (rc)
3705 goto mount_fail_check;
3706
3707 /* now, hang the tcon off of the superblock */
3708 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3709 if (tlink == NULL) {
3710 rc = -ENOMEM;
3711 goto mount_fail_check;
3712 }
3713
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003714 tlink->tl_uid = ses->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003715 tlink->tl_tcon = tcon;
3716 tlink->tl_time = jiffies;
3717 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3718 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3719
Jeff Layton413e6612010-10-28 13:33:38 -04003720 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003721 spin_lock(&cifs_sb->tlink_tree_lock);
3722 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3723 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003724
Jeff Laytonda472fc2012-03-23 14:40:53 -04003725 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003726 TLINK_IDLE_EXPIRE);
3727
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003728mount_fail_check:
3729 /* on error free sesinfo and tcon struct if needed */
3730 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003731 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003732 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003733 if (tcon)
3734 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003735 else if (ses)
3736 cifs_put_smb_ses(ses);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003737 else
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003738 cifs_put_tcp_session(server);
Al Virodd854462011-06-17 08:24:42 -04003739 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003740 }
3741
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003743 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003744 return rc;
3745}
3746
Jeff Layton8d1bca32011-06-11 21:17:10 -04003747/*
3748 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3749 * pointer may be NULL.
3750 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04003752CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
Steve French96daf2b2011-05-27 04:34:02 +00003753 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003754 const struct nls_table *nls_codepage)
3755{
3756 struct smb_hdr *smb_buffer;
3757 struct smb_hdr *smb_buffer_response;
3758 TCONX_REQ *pSMB;
3759 TCONX_RSP *pSMBr;
3760 unsigned char *bcc_ptr;
3761 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003762 int length;
3763 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003764
3765 if (ses == NULL)
3766 return -EIO;
3767
3768 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003769 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003770 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003771
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 smb_buffer_response = smb_buffer;
3773
3774 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3775 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003776
Pavel Shilovsky88257362012-05-23 14:01:59 +04003777 smb_buffer->Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003778 smb_buffer->Uid = ses->Suid;
3779 pSMB = (TCONX_REQ *) smb_buffer;
3780 pSMBr = (TCONX_RSP *) smb_buffer_response;
3781
3782 pSMB->AndXCommand = 0xFF;
3783 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003785 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003786 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003787 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003788 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003789 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003790 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003791 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003792 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3793 specified as required (when that support is added to
3794 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003795 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003796 by Samba (not sure whether other servers allow
3797 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003798#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003799 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton3f618222013-06-12 19:52:14 -05003800 (ses->sectype == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003801 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003802 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003803 SECMODE_PW_ENCRYPT ? true : false,
3804 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003805 else
3806#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003807 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003808 bcc_ptr, nls_codepage);
Steve Frenchf3a31a22015-03-26 19:23:20 -05003809 if (rc) {
3810 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3811 __func__, rc);
3812 cifs_buf_release(smb_buffer);
3813 return rc;
3814 }
Steve Frencheeac8042006-01-13 21:34:58 -08003815
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003816 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003817 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003818 /* must align unicode strings */
3819 *bcc_ptr = 0; /* null byte password */
3820 bcc_ptr++;
3821 }
Steve Frencheeac8042006-01-13 21:34:58 -08003822 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003823
Jeff Layton38d77c52013-05-26 07:01:00 -04003824 if (ses->server->sign)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003825 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3826
3827 if (ses->capabilities & CAP_STATUS32) {
3828 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3829 }
3830 if (ses->capabilities & CAP_DFS) {
3831 smb_buffer->Flags2 |= SMBFLG2_DFS;
3832 }
3833 if (ses->capabilities & CAP_UNICODE) {
3834 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3835 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003836 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003837 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003838 (/* server len*/ + 256 /* share len */), nls_codepage);
3839 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840 bcc_ptr += 2; /* skip trailing null */
3841 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842 strcpy(bcc_ptr, tree);
3843 bcc_ptr += strlen(tree) + 1;
3844 }
3845 strcpy(bcc_ptr, "?????");
3846 bcc_ptr += strlen("?????");
3847 bcc_ptr += 1;
3848 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003849 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3850 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003851 pSMB->ByteCount = cpu_to_le16(count);
3852
Steve French133672e2007-11-13 22:41:37 +00003853 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003854 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003855
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856 /* above now done in SendReceive */
3857 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003858 bool is_unicode;
3859
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003861 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003862 tcon->tid = smb_buffer_response->Tid;
3863 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003864 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003865 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003866 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3867 is_unicode = true;
3868 else
3869 is_unicode = false;
3870
Jeff Laytoncc20c032009-04-30 07:16:21 -04003871
Steve French50c2f752007-07-13 00:33:32 +00003872 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003873 if (length == 3) {
3874 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3875 (bcc_ptr[2] == 'C')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003876 cifs_dbg(FYI, "IPC connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003877 tcon->ipc = 1;
3878 }
3879 } else if (length == 2) {
3880 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3881 /* the most common case */
Joe Perchesf96637b2013-05-04 22:12:25 -05003882 cifs_dbg(FYI, "disk share connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003883 }
3884 }
Steve French50c2f752007-07-13 00:33:32 +00003885 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003886 bytes_left -= (length + 1);
Zhao Hongjiang46b51d02013-06-24 01:57:47 -05003887 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
Jeff Laytoncc20c032009-04-30 07:16:21 -04003888
3889 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003890 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003891 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003892 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003893 nls_codepage);
3894
Joe Perchesf96637b2013-05-04 22:12:25 -05003895 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003896
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003897 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003898 (smb_buffer_response->WordCount == 7))
3899 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003900 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3901 else
3902 tcon->Flags = 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003903 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003904 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003905 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003906 ses->ipc_tid = smb_buffer_response->Tid;
3907 }
3908
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003909 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003910 return rc;
3911}
3912
Al Viro2e32cf52013-10-03 12:53:37 -04003913static void delayed_free(struct rcu_head *p)
3914{
3915 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3916 unload_nls(sbi->local_nls);
3917 kfree(sbi);
3918}
3919
Al Viro2a9b9952011-06-17 09:27:16 -04003920void
3921cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922{
Jeff Laytonb647c352010-10-28 11:16:44 -04003923 struct rb_root *root = &cifs_sb->tlink_tree;
3924 struct rb_node *node;
3925 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926
Jeff Layton2de970f2010-10-06 19:51:12 -04003927 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3928
Jeff Laytonb647c352010-10-28 11:16:44 -04003929 spin_lock(&cifs_sb->tlink_tree_lock);
3930 while ((node = rb_first(root))) {
3931 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3932 cifs_get_tlink(tlink);
3933 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3934 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003935
Jeff Laytonb647c352010-10-28 11:16:44 -04003936 spin_unlock(&cifs_sb->tlink_tree_lock);
3937 cifs_put_tlink(tlink);
3938 spin_lock(&cifs_sb->tlink_tree_lock);
3939 }
3940 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003941
Al Virodd854462011-06-17 08:24:42 -04003942 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003943 kfree(cifs_sb->mountdata);
Al Viro2e32cf52013-10-03 12:53:37 -04003944 call_rcu(&cifs_sb->rcu, delayed_free);
Steve French50c2f752007-07-13 00:33:32 +00003945}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003946
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003947int
3948cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949{
3950 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003951 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003953 if (!server->ops->need_neg || !server->ops->negotiate)
3954 return -ENOSYS;
3955
Jeff Layton198b5682010-04-24 07:57:48 -04003956 /* only send once per connect */
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003957 if (!server->ops->need_neg(server))
Jeff Layton198b5682010-04-24 07:57:48 -04003958 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003959
Pavel Shilovsky45275782012-05-17 17:53:29 +04003960 set_credits(server, 1);
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003961
3962 rc = server->ops->negotiate(xid, ses);
Jeff Layton198b5682010-04-24 07:57:48 -04003963 if (rc == 0) {
3964 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003965 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003966 server->tcpStatus = CifsGood;
3967 else
3968 rc = -EHOSTDOWN;
3969 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003970 }
Steve French26b994f2008-08-06 05:11:33 +00003971
Jeff Layton198b5682010-04-24 07:57:48 -04003972 return rc;
3973}
Steve French26b994f2008-08-06 05:11:33 +00003974
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003975int
3976cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3977 struct nls_table *nls_info)
Jeff Layton198b5682010-04-24 07:57:48 -04003978{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003979 int rc = -ENOSYS;
Jeff Layton198b5682010-04-24 07:57:48 -04003980 struct TCP_Server_Info *server = ses->server;
3981
Jeff Layton198b5682010-04-24 07:57:48 -04003982 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003983 if (linuxExtEnabled == 0)
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003984 ses->capabilities &= (~server->vals->cap_unix);
Steve French20418ac2009-04-30 16:13:32 +00003985
Joe Perchesf96637b2013-05-04 22:12:25 -05003986 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
Steve French96daf2b2011-05-27 04:34:02 +00003987 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003988
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003989 if (server->ops->sess_setup)
3990 rc = server->ops->sess_setup(xid, ses, nls_info);
3991
Shirish Pargaonkard4e63bd2013-08-29 08:35:09 -05003992 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003993 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003994
Linus Torvalds1da177e2005-04-16 15:20:36 -07003995 return rc;
3996}
3997
Jeff Layton8a8798a2012-01-17 16:09:15 -05003998static int
3999cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4000{
Jeff Layton3f618222013-06-12 19:52:14 -05004001 vol->sectype = ses->sectype;
4002
4003 /* krb5 is special, since we don't need username or pw */
4004 if (vol->sectype == Kerberos)
Jeff Layton8a8798a2012-01-17 16:09:15 -05004005 return 0;
Jeff Layton8a8798a2012-01-17 16:09:15 -05004006
4007 return cifs_set_cifscreds(vol, ses);
4008}
4009
Steve French96daf2b2011-05-27 04:34:02 +00004010static struct cifs_tcon *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004011cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
Jeff Layton9d002df2010-10-06 19:51:11 -04004012{
Jeff Layton8a8798a2012-01-17 16:09:15 -05004013 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00004014 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4015 struct cifs_ses *ses;
4016 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04004017 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04004018
4019 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03004020 if (vol_info == NULL)
4021 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04004022
Jeff Layton9d002df2010-10-06 19:51:11 -04004023 vol_info->local_nls = cifs_sb->local_nls;
4024 vol_info->linux_uid = fsuid;
4025 vol_info->cred_uid = fsuid;
4026 vol_info->UNC = master_tcon->treeName;
4027 vol_info->retry = master_tcon->retry;
4028 vol_info->nocase = master_tcon->nocase;
4029 vol_info->local_lease = master_tcon->local_lease;
4030 vol_info->no_linux_ext = !master_tcon->unix_ext;
Jeff Layton28e11bd2013-05-26 07:01:00 -04004031 vol_info->sectype = master_tcon->ses->sectype;
4032 vol_info->sign = master_tcon->ses->sign;
Jeff Layton9d002df2010-10-06 19:51:11 -04004033
Jeff Layton8a8798a2012-01-17 16:09:15 -05004034 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4035 if (rc) {
4036 tcon = ERR_PTR(rc);
4037 goto out;
4038 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004039
4040 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304041 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004042 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304043 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004044
4045 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4046 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00004047 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04004048 cifs_put_tcp_session(master_tcon->ses->server);
4049 goto out;
4050 }
4051
4052 tcon = cifs_get_tcon(ses, vol_info);
4053 if (IS_ERR(tcon)) {
4054 cifs_put_smb_ses(ses);
4055 goto out;
4056 }
4057
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04004058 if (cap_unix(ses))
Jeff Layton9d002df2010-10-06 19:51:11 -04004059 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4060out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05004061 kfree(vol_info->username);
4062 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04004063 kfree(vol_info);
4064
4065 return tcon;
4066}
4067
Steve French96daf2b2011-05-27 04:34:02 +00004068struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04004069cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4070{
4071 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4072}
4073
Jeff Laytonb647c352010-10-28 11:16:44 -04004074/* find and return a tlink with given uid */
4075static struct tcon_link *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004076tlink_rb_search(struct rb_root *root, kuid_t uid)
Jeff Laytonb647c352010-10-28 11:16:44 -04004077{
4078 struct rb_node *node = root->rb_node;
4079 struct tcon_link *tlink;
4080
4081 while (node) {
4082 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4083
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004084 if (uid_gt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004085 node = node->rb_left;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004086 else if (uid_lt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004087 node = node->rb_right;
4088 else
4089 return tlink;
4090 }
4091 return NULL;
4092}
4093
4094/* insert a tcon_link into the tree */
4095static void
4096tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4097{
4098 struct rb_node **new = &(root->rb_node), *parent = NULL;
4099 struct tcon_link *tlink;
4100
4101 while (*new) {
4102 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4103 parent = *new;
4104
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004105 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004106 new = &((*new)->rb_left);
4107 else
4108 new = &((*new)->rb_right);
4109 }
4110
4111 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4112 rb_insert_color(&new_tlink->tl_rbnode, root);
4113}
4114
Jeff Layton9d002df2010-10-06 19:51:11 -04004115/*
4116 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4117 * current task.
4118 *
4119 * If the superblock doesn't refer to a multiuser mount, then just return
4120 * the master tcon for the mount.
4121 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05304122 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04004123 * exists, then check to see if it's pending construction. If it is then wait
4124 * for construction to complete. Once it's no longer pending, check to see if
4125 * it failed and either return an error or retry construction, depending on
4126 * the timeout.
4127 *
4128 * If one doesn't exist then insert a new tcon_link struct into the tree and
4129 * try to construct a new one.
4130 */
4131struct tcon_link *
4132cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4133{
4134 int ret;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004135 kuid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004136 struct tcon_link *tlink, *newtlink;
4137
4138 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4139 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4140
4141 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004142 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004143 if (tlink)
4144 cifs_get_tlink(tlink);
4145 spin_unlock(&cifs_sb->tlink_tree_lock);
4146
4147 if (tlink == NULL) {
4148 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4149 if (newtlink == NULL)
4150 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004151 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004152 newtlink->tl_tcon = ERR_PTR(-EACCES);
4153 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4154 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4155 cifs_get_tlink(newtlink);
4156
Jeff Layton9d002df2010-10-06 19:51:11 -04004157 spin_lock(&cifs_sb->tlink_tree_lock);
4158 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004159 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004160 if (tlink) {
4161 cifs_get_tlink(tlink);
4162 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004163 kfree(newtlink);
4164 goto wait_for_construction;
4165 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004166 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004167 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4168 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004169 } else {
4170wait_for_construction:
4171 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
Jeff Layton9d002df2010-10-06 19:51:11 -04004172 TASK_INTERRUPTIBLE);
4173 if (ret) {
4174 cifs_put_tlink(tlink);
NeilBrown74316202014-07-07 15:16:04 +10004175 return ERR_PTR(-ERESTARTSYS);
Jeff Layton9d002df2010-10-06 19:51:11 -04004176 }
4177
4178 /* if it's good, return it */
4179 if (!IS_ERR(tlink->tl_tcon))
4180 return tlink;
4181
4182 /* return error if we tried this already recently */
4183 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4184 cifs_put_tlink(tlink);
4185 return ERR_PTR(-EACCES);
4186 }
4187
4188 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4189 goto wait_for_construction;
4190 }
4191
4192 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4193 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4194 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4195
4196 if (IS_ERR(tlink->tl_tcon)) {
4197 cifs_put_tlink(tlink);
4198 return ERR_PTR(-EACCES);
4199 }
4200
4201 return tlink;
4202}
Jeff Layton2de970f2010-10-06 19:51:12 -04004203
4204/*
4205 * periodic workqueue job that scans tcon_tree for a superblock and closes
4206 * out tcons.
4207 */
4208static void
4209cifs_prune_tlinks(struct work_struct *work)
4210{
4211 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4212 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004213 struct rb_root *root = &cifs_sb->tlink_tree;
4214 struct rb_node *node = rb_first(root);
4215 struct rb_node *tmp;
4216 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004217
Jeff Laytonb647c352010-10-28 11:16:44 -04004218 /*
4219 * Because we drop the spinlock in the loop in order to put the tlink
4220 * it's not guarded against removal of links from the tree. The only
4221 * places that remove entries from the tree are this function and
4222 * umounts. Because this function is non-reentrant and is canceled
4223 * before umount can proceed, this is safe.
4224 */
4225 spin_lock(&cifs_sb->tlink_tree_lock);
4226 node = rb_first(root);
4227 while (node != NULL) {
4228 tmp = node;
4229 node = rb_next(tmp);
4230 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4231
4232 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4233 atomic_read(&tlink->tl_count) != 0 ||
4234 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4235 continue;
4236
4237 cifs_get_tlink(tlink);
4238 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4239 rb_erase(tmp, root);
4240
Jeff Layton2de970f2010-10-06 19:51:12 -04004241 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004242 cifs_put_tlink(tlink);
4243 spin_lock(&cifs_sb->tlink_tree_lock);
4244 }
4245 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004246
Jeff Laytonda472fc2012-03-23 14:40:53 -04004247 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004248 TLINK_IDLE_EXPIRE);
4249}