blob: 6f62ac821a8459228e50d7a4261482dd4b0d4abe [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
Colin Ian King997152f2016-01-25 16:25:54 +00003002 if (server->server_RFC1001_name[0] != 0)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003003 rfc1002mangle(ses_init_buf->trailer.
3004 session_req.called_name,
3005 server->server_RFC1001_name,
3006 RFC1001_NAME_LEN_WITH_NULL);
3007 else
3008 rfc1002mangle(ses_init_buf->trailer.
3009 session_req.called_name,
3010 DEFAULT_CIFS_CALLED_NAME,
3011 RFC1001_NAME_LEN_WITH_NULL);
3012
3013 ses_init_buf->trailer.session_req.calling_len = 32;
3014
3015 /*
3016 * calling name ends in null (byte 16) from old smb
3017 * convention.
3018 */
Steve Frenchc85c35f2015-03-27 01:15:02 -05003019 if (server->workstation_RFC1001_name[0] != 0)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003020 rfc1002mangle(ses_init_buf->trailer.
3021 session_req.calling_name,
3022 server->workstation_RFC1001_name,
3023 RFC1001_NAME_LEN_WITH_NULL);
3024 else
3025 rfc1002mangle(ses_init_buf->trailer.
3026 session_req.calling_name,
3027 "LINUX_CIFS_CLNT",
3028 RFC1001_NAME_LEN_WITH_NULL);
3029
3030 ses_init_buf->trailer.session_req.scope1 = 0;
3031 ses_init_buf->trailer.session_req.scope2 = 0;
3032 smb_buf = (struct smb_hdr *)ses_init_buf;
3033
3034 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003035 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003036 rc = smb_send(server, smb_buf, 0x44);
3037 kfree(ses_init_buf);
3038 /*
3039 * RFC1001 layer in at least one server
3040 * requires very short break before negprot
3041 * presumably because not expecting negprot
3042 * to follow so fast. This is a simple
3043 * solution that works without
3044 * complicating the code and causes no
3045 * significant slowing down on mount
3046 * for everyone else
3047 */
3048 usleep_range(1000, 2000);
3049 }
3050 /*
3051 * else the negprot may still work without this
3052 * even though malloc failed
3053 */
3054
3055 return rc;
3056}
3057
3058static int
3059generic_ip_connect(struct TCP_Server_Info *server)
3060{
3061 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00003062 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003063 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003064 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003065 struct sockaddr *saddr;
3066
3067 saddr = (struct sockaddr *) &server->dstaddr;
3068
3069 if (server->dstaddr.ss_family == AF_INET6) {
3070 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3071 slen = sizeof(struct sockaddr_in6);
3072 sfamily = AF_INET6;
3073 } else {
3074 sport = ((struct sockaddr_in *) saddr)->sin_port;
3075 slen = sizeof(struct sockaddr_in);
3076 sfamily = AF_INET;
3077 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003079 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06003080 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3081 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003083 cifs_dbg(VFS, "Error %d creating socket\n", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003084 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003087
3088 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesf96637b2013-05-04 22:12:25 -05003089 cifs_dbg(FYI, "Socket created\n");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003090 server->ssocket = socket;
3091 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003092 if (sfamily == AF_INET6)
3093 cifs_reclassify_socket6(socket);
3094 else
3095 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 }
3097
Ben Greear3eb9a882010-09-01 17:06:02 -07003098 rc = bind_socket(server);
3099 if (rc < 0)
3100 return rc;
3101
Jeff Laytond5c56052008-12-01 18:42:33 -05003102 /*
3103 * Eventually check for other socket options to change from
3104 * the default. sock_setsockopt not used because it expects
3105 * user space buffer
3106 */
3107 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00003108 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00003109
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003110 /* make the bufsizes depend on wsize/rsize and max requests */
3111 if (server->noautotune) {
3112 if (socket->sk->sk_sndbuf < (200 * 1024))
3113 socket->sk->sk_sndbuf = 200 * 1024;
3114 if (socket->sk->sk_rcvbuf < (140 * 1024))
3115 socket->sk->sk_rcvbuf = 140 * 1024;
3116 }
3117
Steve French6a5fa2362010-01-01 01:28:43 +00003118 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003119 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00003120 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3121 (char *)&val, sizeof(val));
3122 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003123 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3124 rc);
Steve French6a5fa2362010-01-01 01:28:43 +00003125 }
3126
Joe Perchesf96637b2013-05-04 22:12:25 -05003127 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003128 socket->sk->sk_sndbuf,
3129 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3130
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003131 rc = socket->ops->connect(socket, saddr, slen, 0);
3132 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003133 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003134 sock_release(socket);
3135 server->ssocket = NULL;
3136 return rc;
3137 }
3138
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003139 if (sport == htons(RFC1001_PORT))
3140 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003141
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 return rc;
3143}
3144
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003145static int
3146ip_connect(struct TCP_Server_Info *server)
3147{
Steve French6da97912011-03-13 18:55:55 +00003148 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003149 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3150 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3151
3152 if (server->dstaddr.ss_family == AF_INET6)
3153 sport = &addr6->sin6_port;
3154 else
3155 sport = &addr->sin_port;
3156
3157 if (*sport == 0) {
3158 int rc;
3159
3160 /* try with 445 port at first */
3161 *sport = htons(CIFS_PORT);
3162
3163 rc = generic_ip_connect(server);
3164 if (rc >= 0)
3165 return rc;
3166
3167 /* if it failed, try with 139 port */
3168 *sport = htons(RFC1001_PORT);
3169 }
3170
3171 return generic_ip_connect(server);
3172}
3173
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003174void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003175 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003176{
3177 /* if we are reconnecting then should we check to see if
3178 * any requested capabilities changed locally e.g. via
3179 * remount but we can not do much about it here
3180 * if they have (even if we could detect it by the following)
3181 * Perhaps we could add a backpointer to array of sb from tcon
3182 * or if we change to make all sb to same share the same
3183 * sb as NFS - then we only have one backpointer to sb.
3184 * What if we wanted to mount the server share twice once with
3185 * and once without posixacls or posix paths? */
3186 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003187
Steve Frenchc18c8422007-07-18 23:21:09 +00003188 if (vol_info && vol_info->no_linux_ext) {
3189 tcon->fsUnixInfo.Capability = 0;
3190 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesf96637b2013-05-04 22:12:25 -05003191 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003192 return;
3193 } else if (vol_info)
3194 tcon->unix_ext = 1; /* Unix Extensions supported */
3195
3196 if (tcon->unix_ext == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003197 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003198 return;
3199 }
Steve French50c2f752007-07-13 00:33:32 +00003200
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003201 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003202 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Joe Perchesf96637b2013-05-04 22:12:25 -05003203 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
Steve French8af18972007-02-14 04:42:51 +00003204 /* check for reconnect case in which we do not
3205 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003206 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003207 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003208 originally at mount time */
3209 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3210 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003211 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3212 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003213 cifs_dbg(VFS, "POSIXPATH support change\n");
Steve French8af18972007-02-14 04:42:51 +00003214 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003215 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003216 cifs_dbg(VFS, "possible reconnect error\n");
3217 cifs_dbg(VFS, "server disabled POSIX path support\n");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003218 }
Steve French8af18972007-02-14 04:42:51 +00003219 }
Steve French50c2f752007-07-13 00:33:32 +00003220
Steve French6848b732011-05-26 18:38:54 +00003221 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003222 cifs_dbg(VFS, "per-share encryption not supported yet\n");
Steve French6848b732011-05-26 18:38:54 +00003223
Steve French8af18972007-02-14 04:42:51 +00003224 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00003225 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003226 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003227 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003228 cifs_dbg(FYI, "negotiated posix acl support\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003229 if (cifs_sb)
3230 cifs_sb->mnt_cifs_flags |=
3231 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003232 }
3233
Steve French75865f8c2007-06-24 18:30:48 +00003234 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003235 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003236 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003237 cifs_dbg(FYI, "negotiate posix pathnames\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003238 if (cifs_sb)
3239 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003240 CIFS_MOUNT_POSIX_PATHS;
3241 }
Steve French50c2f752007-07-13 00:33:32 +00003242
Joe Perchesf96637b2013-05-04 22:12:25 -05003243 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003244#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00003245 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003246 cifs_dbg(FYI, "FCNTL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003247 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003248 cifs_dbg(FYI, "EXTATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003249 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003250 cifs_dbg(FYI, "POSIX path cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003251 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003252 cifs_dbg(FYI, "XATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003253 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003254 cifs_dbg(FYI, "POSIX ACL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003255 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003256 cifs_dbg(FYI, "very large read cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003257 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003258 cifs_dbg(FYI, "very large write cap\n");
Steve French6848b732011-05-26 18:38:54 +00003259 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003260 cifs_dbg(FYI, "transport encryption cap\n");
Steve French6848b732011-05-26 18:38:54 +00003261 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003262 cifs_dbg(FYI, "mandatory transport encryption cap\n");
Steve French8af18972007-02-14 04:42:51 +00003263#endif /* CIFS_DEBUG2 */
3264 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003265 if (vol_info == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003266 cifs_dbg(FYI, "resetting capabilities failed\n");
Steve French442aa312007-09-24 20:25:46 +00003267 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05003268 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 +00003269
Steve French8af18972007-02-14 04:42:51 +00003270 }
3271 }
3272}
3273
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003274void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3275 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003276{
Jeff Layton2de970f2010-10-06 19:51:12 -04003277 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3278
Al Viro2ced6f62011-06-17 09:20:04 -04003279 spin_lock_init(&cifs_sb->tlink_tree_lock);
3280 cifs_sb->tlink_tree = RB_ROOT;
3281
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003282 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003283 * Temporarily set r/wsize for matching superblock. If we end up using
3284 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003285 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003286 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003287 cifs_sb->wsize = pvolume_info->wsize;
3288
Steve French3b795212008-11-13 19:45:32 +00003289 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3290 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3291 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3292 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -05003293 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3294 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003295
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303296 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003297 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303298
Steve French3b795212008-11-13 19:45:32 +00003299 if (pvolume_info->noperm)
3300 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3301 if (pvolume_info->setuids)
3302 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3303 if (pvolume_info->server_ino)
3304 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3305 if (pvolume_info->remap)
Steve French2baa2682014-09-27 02:19:01 -05003306 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3307 if (pvolume_info->sfu_remap)
Steve French3b795212008-11-13 19:45:32 +00003308 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3309 if (pvolume_info->no_xattr)
3310 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3311 if (pvolume_info->sfu_emul)
3312 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3313 if (pvolume_info->nobrl)
3314 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003315 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003316 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003317 if (pvolume_info->mand_lock)
3318 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003319 if (pvolume_info->rwpidforward)
3320 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003321 if (pvolume_info->cifs_acl)
3322 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003323 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003324 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003325 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3326 }
3327 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003328 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003329 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3330 }
Steve French3b795212008-11-13 19:45:32 +00003331 if (pvolume_info->override_uid)
3332 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3333 if (pvolume_info->override_gid)
3334 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3335 if (pvolume_info->dynperm)
3336 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303337 if (pvolume_info->fsc)
3338 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003339 if (pvolume_info->multiuser)
3340 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3341 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003342 if (pvolume_info->strict_io)
3343 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003344 if (pvolume_info->direct_io) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003345 cifs_dbg(FYI, "mounting share using direct i/o\n");
Steve French3b795212008-11-13 19:45:32 +00003346 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3347 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003348 if (pvolume_info->mfsymlinks) {
3349 if (pvolume_info->sfu_emul) {
Steve Frenchdb8b6312014-09-22 05:13:55 -05003350 /*
3351 * Our SFU ("Services for Unix" emulation does not allow
3352 * creating symlinks but does allow reading existing SFU
3353 * symlinks (it does allow both creating and reading SFU
3354 * style mknod and FIFOs though). When "mfsymlinks" and
3355 * "sfu" are both enabled at the same time, it allows
3356 * reading both types of symlinks, but will only create
3357 * them with mfsymlinks format. This allows better
3358 * Apple compatibility (probably better for Samba too)
3359 * while still recognizing old Windows style symlinks.
3360 */
3361 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003362 }
Steve Frenchdb8b6312014-09-22 05:13:55 -05003363 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003364 }
Steve French3b795212008-11-13 19:45:32 +00003365
3366 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesf96637b2013-05-04 22:12:25 -05003367 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003368}
3369
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003370static void
3371cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003372{
Sean Finneyb9468452011-04-11 13:19:32 +00003373 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003374 kzfree(volume_info->password);
Jesper Juhl95c75452011-08-27 18:58:34 +02003375 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003376 kfree(volume_info->domainname);
3377 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003378 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003379}
3380
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003381void
3382cifs_cleanup_volume_info(struct smb_vol *volume_info)
3383{
3384 if (!volume_info)
3385 return;
3386 cleanup_volume_info_contents(volume_info);
3387 kfree(volume_info);
3388}
3389
3390
Steve French2d6d5892009-04-09 00:36:44 +00003391#ifdef CONFIG_CIFS_DFS_UPCALL
Steve French6d3ea7e2012-11-28 22:34:41 -06003392/*
3393 * cifs_build_path_to_root returns full path to root when we do not have an
3394 * exiting connection (tcon)
3395 */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003396static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003397build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003398 const struct cifs_sb_info *cifs_sb)
3399{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003400 char *full_path, *pos;
Jeff Layton839db3d2012-12-10 06:10:45 -05003401 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003402 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003403
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003404 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003405 if (full_path == NULL)
3406 return ERR_PTR(-ENOMEM);
3407
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003408 strncpy(full_path, vol->UNC, unc_len);
3409 pos = full_path + unc_len;
3410
3411 if (pplen) {
Jeff Layton1fc29ba2013-05-31 10:00:18 -04003412 *pos = CIFS_DIR_SEP(cifs_sb);
3413 strncpy(pos + 1, vol->prepath, pplen);
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003414 pos += pplen;
3415 }
3416
3417 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003418 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05003419 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003420 return full_path;
3421}
Sean Finneydd613942011-04-11 13:19:30 +00003422
3423/*
3424 * Perform a dfs referral query for a share and (optionally) prefix
3425 *
Sean Finney046462a2011-04-11 13:19:33 +00003426 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3427 * to a string containing updated options for the submount. Otherwise it
3428 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003429 *
3430 * Returns the rc from get_dfs_path to the caller, which can be used to
3431 * determine whether there were referrals.
3432 */
3433static int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003434expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
Sean Finneydd613942011-04-11 13:19:30 +00003435 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003436 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003437{
3438 int rc;
3439 unsigned int num_referrals = 0;
3440 struct dfs_info3_param *referrals = NULL;
3441 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3442
3443 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3444 if (IS_ERR(full_path))
3445 return PTR_ERR(full_path);
3446
3447 /* For DFS paths, skip the first '\' of the UNC */
3448 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3449
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003450 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05003451 &num_referrals, &referrals, cifs_remap(cifs_sb));
Sean Finneydd613942011-04-11 13:19:30 +00003452
3453 if (!rc && num_referrals > 0) {
3454 char *fake_devname = NULL;
3455
3456 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3457 full_path + 1, referrals,
3458 &fake_devname);
3459
3460 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003461
Sean Finneydd613942011-04-11 13:19:30 +00003462 if (IS_ERR(mdata)) {
3463 rc = PTR_ERR(mdata);
3464 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003465 } else {
3466 cleanup_volume_info_contents(volume_info);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003467 rc = cifs_setup_volume_info(volume_info, mdata,
3468 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003469 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003470 kfree(fake_devname);
3471 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003472 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003473 }
3474 kfree(full_path);
3475 return rc;
3476}
Steve French2d6d5892009-04-09 00:36:44 +00003477#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003478
Jeff Layton04db79b2011-07-06 08:10:38 -04003479static int
3480cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3481 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003483 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003484
Jeff Layton04db79b2011-07-06 08:10:38 -04003485 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3486 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487
Jeff Layton7586b762008-12-01 18:41:49 -05003488 if (volume_info->nullauth) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003489 cifs_dbg(FYI, "Anonymous login\n");
Jeff Layton04febab2012-01-17 16:09:15 -05003490 kfree(volume_info->username);
3491 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003492 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 /* BB fixme parse for domain name here */
Joe Perchesf96637b2013-05-04 22:12:25 -05003494 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05003496 cifs_dbg(VFS, "No username specified\n");
Steve French50c2f752007-07-13 00:33:32 +00003497 /* In userspace mount helper we can get user name from alternate
3498 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003499 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500 }
3501
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003503 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003504 /* load_nls_default cannot return null */
3505 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003507 volume_info->local_nls = load_nls(volume_info->iocharset);
3508 if (volume_info->local_nls == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003509 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003510 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003511 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 }
3513 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003514
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003515 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003516}
3517
3518struct smb_vol *
3519cifs_get_volume_info(char *mount_data, const char *devname)
3520{
3521 int rc;
3522 struct smb_vol *volume_info;
3523
Jeff Layton6ee95422012-11-26 11:09:57 -05003524 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003525 if (!volume_info)
3526 return ERR_PTR(-ENOMEM);
3527
3528 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3529 if (rc) {
3530 cifs_cleanup_volume_info(volume_info);
3531 volume_info = ERR_PTR(rc);
3532 }
3533
3534 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003535}
3536
3537int
Al Viro2c6292a2011-06-17 09:05:48 -04003538cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003539{
Jeff Layton1daaae82012-03-21 06:30:40 -04003540 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003541 unsigned int xid;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003542 struct cifs_ses *ses;
Steve French96daf2b2011-05-27 04:34:02 +00003543 struct cifs_tcon *tcon;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003544 struct TCP_Server_Info *server;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003545 char *full_path;
3546 struct tcon_link *tlink;
3547#ifdef CONFIG_CIFS_DFS_UPCALL
3548 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003549#endif
Al Virodd854462011-06-17 08:24:42 -04003550
Christoph Hellwigb4caecd2015-01-14 10:42:32 +01003551 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
Al Virodd854462011-06-17 08:24:42 -04003552 if (rc)
3553 return rc;
3554
Jeff Layton20547492011-07-09 12:21:07 -04003555#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003556try_mount_again:
3557 /* cleanup activities if we're chasing a referral */
3558 if (referral_walks_count) {
3559 if (tcon)
3560 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003561 else if (ses)
3562 cifs_put_smb_ses(ses);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003563
Sachin Prabhu1dfd18d2015-06-16 16:36:17 +01003564 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3565
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003566 free_xid(xid);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003567 }
3568#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003569 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003570 tcon = NULL;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003571 ses = NULL;
3572 server = NULL;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003573 full_path = NULL;
3574 tlink = NULL;
3575
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003576 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577
Jeff Layton63c038c2008-12-01 18:41:46 -05003578 /* get a reference to a tcp session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003579 server = cifs_get_tcp_session(volume_info);
3580 if (IS_ERR(server)) {
3581 rc = PTR_ERR(server);
Al Virodd854462011-06-17 08:24:42 -04003582 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003583 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584 }
3585
Jeff Layton36988c72010-04-24 07:57:43 -04003586 /* get a reference to a SMB session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003587 ses = cifs_get_smb_ses(server, volume_info);
3588 if (IS_ERR(ses)) {
3589 rc = PTR_ERR(ses);
3590 ses = NULL;
Jeff Layton36988c72010-04-24 07:57:43 -04003591 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 }
Steve French50c2f752007-07-13 00:33:32 +00003593
Steve French592fafe2015-11-03 10:08:53 -06003594#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06003595 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3596 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3597 cifs_dbg(VFS, "persistent handles not supported by server\n");
3598 rc = -EOPNOTSUPP;
3599 goto mount_fail_check;
3600 }
Steve French592fafe2015-11-03 10:08:53 -06003601#endif /* CONFIG_CIFS_SMB2*/
3602
Jeff Laytond00c28d2010-04-24 07:57:44 -04003603 /* search for existing tcon to this server share */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003604 tcon = cifs_get_tcon(ses, volume_info);
Jeff Laytond00c28d2010-04-24 07:57:44 -04003605 if (IS_ERR(tcon)) {
3606 rc = PTR_ERR(tcon);
3607 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003608 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003609 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003610
Steve French6848b732011-05-26 18:38:54 +00003611 /* tell server which Unix caps we support */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003612 if (cap_unix(tcon->ses)) {
Steve French6848b732011-05-26 18:38:54 +00003613 /* reset of caps checks mount to see if unix extensions
3614 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003615 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003616 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3617 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3618 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3619 rc = -EACCES;
3620 goto mount_fail_check;
3621 }
3622 } else
3623 tcon->unix_ext = 0; /* server does not support them */
3624
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003625 /* do not care if a following call succeed - informational */
3626 if (!tcon->ipc && server->ops->qfs_tcon)
3627 server->ops->qfs_tcon(xid, tcon);
Steve Frenchd82c2df2008-11-15 00:07:26 +00003628
Pavel Shilovsky24985c52012-09-18 16:20:28 -07003629 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3630 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003631
Jeff Layton66bfaad2011-10-19 15:30:35 -04003632 /* tune readahead according to rsize */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03003633 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003634
Igor Mammedove4cce942009-02-10 14:10:26 +03003635remote_path_check:
3636#ifdef CONFIG_CIFS_DFS_UPCALL
3637 /*
3638 * Perform an unconditional check for whether there are DFS
3639 * referrals for this path without prefix, to provide support
3640 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003641 * with PATH_NOT_COVERED to requests that include the prefix.
3642 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003643 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003644 if (referral_walks_count == 0) {
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003645 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3646 false);
Steve Frencheeac8042006-01-13 21:34:58 -08003647 if (!refrc) {
Steve French4523cc32007-04-30 20:13:06 +00003648 referral_walks_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649 goto try_mount_again;
3650 }
3651 }
3652#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003653
Steve Frenchf87d39d2011-05-27 03:50:55 +00003654 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003655 if (!rc && tcon) {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003656 if (!server->ops->is_path_accessible) {
3657 rc = -ENOSYS;
3658 goto mount_fail_check;
3659 }
Steve French6d3ea7e2012-11-28 22:34:41 -06003660 /*
3661 * cifs_build_path_to_root works only when we have a valid tcon
3662 */
3663 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664 if (full_path == NULL) {
3665 rc = -ENOMEM;
3666 goto mount_fail_check;
3667 }
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003668 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3669 full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003670 if (rc != 0 && rc != -EREMOTE) {
3671 kfree(full_path);
3672 goto mount_fail_check;
3673 }
3674 kfree(full_path);
3675 }
3676
3677 /* get referral if needed */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003678 if (rc == -EREMOTE) {
3679#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003680 if (referral_walks_count > MAX_NESTED_LINKS) {
3681 /*
3682 * BB: when we implement proper loop detection,
3683 * we will remove this check. But now we need it
3684 * to prevent an indefinite loop if 'DFS tree' is
3685 * misconfigured (i.e. has loops).
3686 */
3687 rc = -ELOOP;
3688 goto mount_fail_check;
3689 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003690
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003691 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003692
Sean Finneydd613942011-04-11 13:19:30 +00003693 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003694 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003695 goto try_mount_again;
3696 }
Sean Finneydd613942011-04-11 13:19:30 +00003697 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003698#else /* No DFS support, return error on mount */
3699 rc = -EOPNOTSUPP;
3700#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003701 }
3702
Jeff Layton9d002df2010-10-06 19:51:11 -04003703 if (rc)
3704 goto mount_fail_check;
3705
3706 /* now, hang the tcon off of the superblock */
3707 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3708 if (tlink == NULL) {
3709 rc = -ENOMEM;
3710 goto mount_fail_check;
3711 }
3712
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003713 tlink->tl_uid = ses->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003714 tlink->tl_tcon = tcon;
3715 tlink->tl_time = jiffies;
3716 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3717 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3718
Jeff Layton413e6612010-10-28 13:33:38 -04003719 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003720 spin_lock(&cifs_sb->tlink_tree_lock);
3721 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3722 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003723
Jeff Laytonda472fc2012-03-23 14:40:53 -04003724 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003725 TLINK_IDLE_EXPIRE);
3726
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003727mount_fail_check:
3728 /* on error free sesinfo and tcon struct if needed */
3729 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003730 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003731 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003732 if (tcon)
3733 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003734 else if (ses)
3735 cifs_put_smb_ses(ses);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003736 else
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003737 cifs_put_tcp_session(server);
Al Virodd854462011-06-17 08:24:42 -04003738 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003739 }
3740
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003742 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743 return rc;
3744}
3745
Jeff Layton8d1bca32011-06-11 21:17:10 -04003746/*
3747 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3748 * pointer may be NULL.
3749 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04003751CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
Steve French96daf2b2011-05-27 04:34:02 +00003752 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003753 const struct nls_table *nls_codepage)
3754{
3755 struct smb_hdr *smb_buffer;
3756 struct smb_hdr *smb_buffer_response;
3757 TCONX_REQ *pSMB;
3758 TCONX_RSP *pSMBr;
3759 unsigned char *bcc_ptr;
3760 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003761 int length;
3762 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003763
3764 if (ses == NULL)
3765 return -EIO;
3766
3767 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003768 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003769 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003770
Linus Torvalds1da177e2005-04-16 15:20:36 -07003771 smb_buffer_response = smb_buffer;
3772
3773 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3774 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003775
Pavel Shilovsky88257362012-05-23 14:01:59 +04003776 smb_buffer->Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003777 smb_buffer->Uid = ses->Suid;
3778 pSMB = (TCONX_REQ *) smb_buffer;
3779 pSMBr = (TCONX_RSP *) smb_buffer_response;
3780
3781 pSMB->AndXCommand = 0xFF;
3782 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003783 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003784 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003785 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003786 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003787 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003788 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003789 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003790 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003791 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3792 specified as required (when that support is added to
3793 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003794 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003795 by Samba (not sure whether other servers allow
3796 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003797#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003798 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton3f618222013-06-12 19:52:14 -05003799 (ses->sectype == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003800 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003801 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003802 SECMODE_PW_ENCRYPT ? true : false,
3803 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003804 else
3805#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003806 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003807 bcc_ptr, nls_codepage);
Steve Frenchf3a31a22015-03-26 19:23:20 -05003808 if (rc) {
3809 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3810 __func__, rc);
3811 cifs_buf_release(smb_buffer);
3812 return rc;
3813 }
Steve Frencheeac8042006-01-13 21:34:58 -08003814
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003815 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003816 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003817 /* must align unicode strings */
3818 *bcc_ptr = 0; /* null byte password */
3819 bcc_ptr++;
3820 }
Steve Frencheeac8042006-01-13 21:34:58 -08003821 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003822
Jeff Layton38d77c52013-05-26 07:01:00 -04003823 if (ses->server->sign)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3825
3826 if (ses->capabilities & CAP_STATUS32) {
3827 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3828 }
3829 if (ses->capabilities & CAP_DFS) {
3830 smb_buffer->Flags2 |= SMBFLG2_DFS;
3831 }
3832 if (ses->capabilities & CAP_UNICODE) {
3833 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3834 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003835 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003836 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003837 (/* server len*/ + 256 /* share len */), nls_codepage);
3838 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839 bcc_ptr += 2; /* skip trailing null */
3840 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 strcpy(bcc_ptr, tree);
3842 bcc_ptr += strlen(tree) + 1;
3843 }
3844 strcpy(bcc_ptr, "?????");
3845 bcc_ptr += strlen("?????");
3846 bcc_ptr += 1;
3847 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003848 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3849 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850 pSMB->ByteCount = cpu_to_le16(count);
3851
Steve French133672e2007-11-13 22:41:37 +00003852 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003853 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003854
Linus Torvalds1da177e2005-04-16 15:20:36 -07003855 /* above now done in SendReceive */
3856 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003857 bool is_unicode;
3858
Linus Torvalds1da177e2005-04-16 15:20:36 -07003859 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003860 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003861 tcon->tid = smb_buffer_response->Tid;
3862 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003863 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003864 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003865 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3866 is_unicode = true;
3867 else
3868 is_unicode = false;
3869
Jeff Laytoncc20c032009-04-30 07:16:21 -04003870
Steve French50c2f752007-07-13 00:33:32 +00003871 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003872 if (length == 3) {
3873 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3874 (bcc_ptr[2] == 'C')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003875 cifs_dbg(FYI, "IPC connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003876 tcon->ipc = 1;
3877 }
3878 } else if (length == 2) {
3879 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3880 /* the most common case */
Joe Perchesf96637b2013-05-04 22:12:25 -05003881 cifs_dbg(FYI, "disk share connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003882 }
3883 }
Steve French50c2f752007-07-13 00:33:32 +00003884 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003885 bytes_left -= (length + 1);
Zhao Hongjiang46b51d02013-06-24 01:57:47 -05003886 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
Jeff Laytoncc20c032009-04-30 07:16:21 -04003887
3888 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003889 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003890 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003891 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003892 nls_codepage);
3893
Joe Perchesf96637b2013-05-04 22:12:25 -05003894 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003895
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003896 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003897 (smb_buffer_response->WordCount == 7))
3898 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003899 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3900 else
3901 tcon->Flags = 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003902 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003903 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003904 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003905 ses->ipc_tid = smb_buffer_response->Tid;
3906 }
3907
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003908 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003909 return rc;
3910}
3911
Al Viro2e32cf52013-10-03 12:53:37 -04003912static void delayed_free(struct rcu_head *p)
3913{
3914 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3915 unload_nls(sbi->local_nls);
3916 kfree(sbi);
3917}
3918
Al Viro2a9b9952011-06-17 09:27:16 -04003919void
3920cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003921{
Jeff Laytonb647c352010-10-28 11:16:44 -04003922 struct rb_root *root = &cifs_sb->tlink_tree;
3923 struct rb_node *node;
3924 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003925
Jeff Layton2de970f2010-10-06 19:51:12 -04003926 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3927
Jeff Laytonb647c352010-10-28 11:16:44 -04003928 spin_lock(&cifs_sb->tlink_tree_lock);
3929 while ((node = rb_first(root))) {
3930 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3931 cifs_get_tlink(tlink);
3932 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3933 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003934
Jeff Laytonb647c352010-10-28 11:16:44 -04003935 spin_unlock(&cifs_sb->tlink_tree_lock);
3936 cifs_put_tlink(tlink);
3937 spin_lock(&cifs_sb->tlink_tree_lock);
3938 }
3939 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003940
Al Virodd854462011-06-17 08:24:42 -04003941 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003942 kfree(cifs_sb->mountdata);
Al Viro2e32cf52013-10-03 12:53:37 -04003943 call_rcu(&cifs_sb->rcu, delayed_free);
Steve French50c2f752007-07-13 00:33:32 +00003944}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003946int
3947cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003948{
3949 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003950 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003952 if (!server->ops->need_neg || !server->ops->negotiate)
3953 return -ENOSYS;
3954
Jeff Layton198b5682010-04-24 07:57:48 -04003955 /* only send once per connect */
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003956 if (!server->ops->need_neg(server))
Jeff Layton198b5682010-04-24 07:57:48 -04003957 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958
Pavel Shilovsky45275782012-05-17 17:53:29 +04003959 set_credits(server, 1);
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003960
3961 rc = server->ops->negotiate(xid, ses);
Jeff Layton198b5682010-04-24 07:57:48 -04003962 if (rc == 0) {
3963 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003964 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003965 server->tcpStatus = CifsGood;
3966 else
3967 rc = -EHOSTDOWN;
3968 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 }
Steve French26b994f2008-08-06 05:11:33 +00003970
Jeff Layton198b5682010-04-24 07:57:48 -04003971 return rc;
3972}
Steve French26b994f2008-08-06 05:11:33 +00003973
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003974int
3975cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3976 struct nls_table *nls_info)
Jeff Layton198b5682010-04-24 07:57:48 -04003977{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003978 int rc = -ENOSYS;
Jeff Layton198b5682010-04-24 07:57:48 -04003979 struct TCP_Server_Info *server = ses->server;
3980
Jeff Layton198b5682010-04-24 07:57:48 -04003981 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003982 if (linuxExtEnabled == 0)
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003983 ses->capabilities &= (~server->vals->cap_unix);
Steve French20418ac2009-04-30 16:13:32 +00003984
Joe Perchesf96637b2013-05-04 22:12:25 -05003985 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
Steve French96daf2b2011-05-27 04:34:02 +00003986 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003987
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003988 if (server->ops->sess_setup)
3989 rc = server->ops->sess_setup(xid, ses, nls_info);
3990
Shirish Pargaonkard4e63bd2013-08-29 08:35:09 -05003991 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003992 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003993
Linus Torvalds1da177e2005-04-16 15:20:36 -07003994 return rc;
3995}
3996
Jeff Layton8a8798a2012-01-17 16:09:15 -05003997static int
3998cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3999{
Jeff Layton3f618222013-06-12 19:52:14 -05004000 vol->sectype = ses->sectype;
4001
4002 /* krb5 is special, since we don't need username or pw */
4003 if (vol->sectype == Kerberos)
Jeff Layton8a8798a2012-01-17 16:09:15 -05004004 return 0;
Jeff Layton8a8798a2012-01-17 16:09:15 -05004005
4006 return cifs_set_cifscreds(vol, ses);
4007}
4008
Steve French96daf2b2011-05-27 04:34:02 +00004009static struct cifs_tcon *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004010cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
Jeff Layton9d002df2010-10-06 19:51:11 -04004011{
Jeff Layton8a8798a2012-01-17 16:09:15 -05004012 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00004013 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4014 struct cifs_ses *ses;
4015 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04004016 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04004017
4018 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03004019 if (vol_info == NULL)
4020 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04004021
Jeff Layton9d002df2010-10-06 19:51:11 -04004022 vol_info->local_nls = cifs_sb->local_nls;
4023 vol_info->linux_uid = fsuid;
4024 vol_info->cred_uid = fsuid;
4025 vol_info->UNC = master_tcon->treeName;
4026 vol_info->retry = master_tcon->retry;
4027 vol_info->nocase = master_tcon->nocase;
4028 vol_info->local_lease = master_tcon->local_lease;
4029 vol_info->no_linux_ext = !master_tcon->unix_ext;
Jeff Layton28e11bd2013-05-26 07:01:00 -04004030 vol_info->sectype = master_tcon->ses->sectype;
4031 vol_info->sign = master_tcon->ses->sign;
Jeff Layton9d002df2010-10-06 19:51:11 -04004032
Jeff Layton8a8798a2012-01-17 16:09:15 -05004033 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4034 if (rc) {
4035 tcon = ERR_PTR(rc);
4036 goto out;
4037 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004038
4039 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304040 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004041 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304042 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004043
4044 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4045 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00004046 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04004047 cifs_put_tcp_session(master_tcon->ses->server);
4048 goto out;
4049 }
4050
4051 tcon = cifs_get_tcon(ses, vol_info);
4052 if (IS_ERR(tcon)) {
4053 cifs_put_smb_ses(ses);
4054 goto out;
4055 }
4056
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04004057 if (cap_unix(ses))
Jeff Layton9d002df2010-10-06 19:51:11 -04004058 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4059out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05004060 kfree(vol_info->username);
4061 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04004062 kfree(vol_info);
4063
4064 return tcon;
4065}
4066
Steve French96daf2b2011-05-27 04:34:02 +00004067struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04004068cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4069{
4070 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4071}
4072
Jeff Laytonb647c352010-10-28 11:16:44 -04004073/* find and return a tlink with given uid */
4074static struct tcon_link *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004075tlink_rb_search(struct rb_root *root, kuid_t uid)
Jeff Laytonb647c352010-10-28 11:16:44 -04004076{
4077 struct rb_node *node = root->rb_node;
4078 struct tcon_link *tlink;
4079
4080 while (node) {
4081 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4082
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004083 if (uid_gt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004084 node = node->rb_left;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004085 else if (uid_lt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004086 node = node->rb_right;
4087 else
4088 return tlink;
4089 }
4090 return NULL;
4091}
4092
4093/* insert a tcon_link into the tree */
4094static void
4095tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4096{
4097 struct rb_node **new = &(root->rb_node), *parent = NULL;
4098 struct tcon_link *tlink;
4099
4100 while (*new) {
4101 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4102 parent = *new;
4103
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004104 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004105 new = &((*new)->rb_left);
4106 else
4107 new = &((*new)->rb_right);
4108 }
4109
4110 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4111 rb_insert_color(&new_tlink->tl_rbnode, root);
4112}
4113
Jeff Layton9d002df2010-10-06 19:51:11 -04004114/*
4115 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4116 * current task.
4117 *
4118 * If the superblock doesn't refer to a multiuser mount, then just return
4119 * the master tcon for the mount.
4120 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05304121 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04004122 * exists, then check to see if it's pending construction. If it is then wait
4123 * for construction to complete. Once it's no longer pending, check to see if
4124 * it failed and either return an error or retry construction, depending on
4125 * the timeout.
4126 *
4127 * If one doesn't exist then insert a new tcon_link struct into the tree and
4128 * try to construct a new one.
4129 */
4130struct tcon_link *
4131cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4132{
4133 int ret;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004134 kuid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004135 struct tcon_link *tlink, *newtlink;
4136
4137 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4138 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4139
4140 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004141 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004142 if (tlink)
4143 cifs_get_tlink(tlink);
4144 spin_unlock(&cifs_sb->tlink_tree_lock);
4145
4146 if (tlink == NULL) {
4147 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4148 if (newtlink == NULL)
4149 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004150 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004151 newtlink->tl_tcon = ERR_PTR(-EACCES);
4152 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4153 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4154 cifs_get_tlink(newtlink);
4155
Jeff Layton9d002df2010-10-06 19:51:11 -04004156 spin_lock(&cifs_sb->tlink_tree_lock);
4157 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004158 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004159 if (tlink) {
4160 cifs_get_tlink(tlink);
4161 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004162 kfree(newtlink);
4163 goto wait_for_construction;
4164 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004165 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004166 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4167 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004168 } else {
4169wait_for_construction:
4170 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
Jeff Layton9d002df2010-10-06 19:51:11 -04004171 TASK_INTERRUPTIBLE);
4172 if (ret) {
4173 cifs_put_tlink(tlink);
NeilBrown74316202014-07-07 15:16:04 +10004174 return ERR_PTR(-ERESTARTSYS);
Jeff Layton9d002df2010-10-06 19:51:11 -04004175 }
4176
4177 /* if it's good, return it */
4178 if (!IS_ERR(tlink->tl_tcon))
4179 return tlink;
4180
4181 /* return error if we tried this already recently */
4182 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4183 cifs_put_tlink(tlink);
4184 return ERR_PTR(-EACCES);
4185 }
4186
4187 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4188 goto wait_for_construction;
4189 }
4190
4191 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4192 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4193 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4194
4195 if (IS_ERR(tlink->tl_tcon)) {
4196 cifs_put_tlink(tlink);
4197 return ERR_PTR(-EACCES);
4198 }
4199
4200 return tlink;
4201}
Jeff Layton2de970f2010-10-06 19:51:12 -04004202
4203/*
4204 * periodic workqueue job that scans tcon_tree for a superblock and closes
4205 * out tcons.
4206 */
4207static void
4208cifs_prune_tlinks(struct work_struct *work)
4209{
4210 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4211 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004212 struct rb_root *root = &cifs_sb->tlink_tree;
4213 struct rb_node *node = rb_first(root);
4214 struct rb_node *tmp;
4215 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004216
Jeff Laytonb647c352010-10-28 11:16:44 -04004217 /*
4218 * Because we drop the spinlock in the loop in order to put the tlink
4219 * it's not guarded against removal of links from the tree. The only
4220 * places that remove entries from the tree are this function and
4221 * umounts. Because this function is non-reentrant and is canceled
4222 * before umount can proceed, this is safe.
4223 */
4224 spin_lock(&cifs_sb->tlink_tree_lock);
4225 node = rb_first(root);
4226 while (node != NULL) {
4227 tmp = node;
4228 node = rb_next(tmp);
4229 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4230
4231 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4232 atomic_read(&tlink->tl_count) != 0 ||
4233 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4234 continue;
4235
4236 cifs_get_tlink(tlink);
4237 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4238 rb_erase(tmp, root);
4239
Jeff Layton2de970f2010-10-06 19:51:12 -04004240 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004241 cifs_put_tlink(tlink);
4242 spin_lock(&cifs_sb->tlink_tree_lock);
4243 }
4244 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004245
Jeff Laytonda472fc2012-03-23 14:40:53 -04004246 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004247 TLINK_IDLE_EXPIRE);
4248}