blob: 17c3643e595095597e90026ea6a337edb7bd8b0b [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,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
76 Opt_nocase,
77 Opt_brl, Opt_nobrl,
78 Opt_forcemandatorylock, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
81 Opt_nointr, Opt_intr,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
Jeff Layton1b359202012-09-19 15:20:27 -070086 Opt_sign, Opt_seal, Opt_noac,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040087 Opt_fsc, Opt_mfsymlinks,
Jeff Laytond8162552012-03-23 14:40:56 -040088 Opt_multiuser, Opt_sloppy,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040089
90 /* Mount options which take numeric value */
91 Opt_backupuid, Opt_backupgid, Opt_uid,
92 Opt_cruid, Opt_gid, Opt_file_mode,
93 Opt_dirmode, Opt_port,
94 Opt_rsize, Opt_wsize, Opt_actimeo,
95
96 /* Mount options which take string value */
97 Opt_user, Opt_pass, Opt_ip,
98 Opt_unc, Opt_domain,
99 Opt_srcaddr, Opt_prefixpath,
100 Opt_iocharset, Opt_sockopt,
101 Opt_netbiosname, Opt_servern,
Jeff Layton23db65f2012-05-15 12:20:51 -0400102 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400103
104 /* Mount options to be ignored */
105 Opt_ignore,
106
107 /* Options which could be blank */
108 Opt_blank_pass,
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100109 Opt_blank_user,
110 Opt_blank_ip,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400111
112 Opt_err
113};
114
115static const match_table_t cifs_mount_option_tokens = {
116
117 { Opt_user_xattr, "user_xattr" },
118 { Opt_nouser_xattr, "nouser_xattr" },
119 { Opt_forceuid, "forceuid" },
120 { Opt_noforceuid, "noforceuid" },
Jeff Layton72bd4812012-10-03 16:02:36 -0400121 { Opt_forcegid, "forcegid" },
122 { Opt_noforcegid, "noforcegid" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400123 { Opt_noblocksend, "noblocksend" },
124 { Opt_noautotune, "noautotune" },
125 { Opt_hard, "hard" },
126 { Opt_soft, "soft" },
127 { Opt_perm, "perm" },
128 { Opt_noperm, "noperm" },
129 { Opt_mapchars, "mapchars" },
130 { Opt_nomapchars, "nomapchars" },
131 { Opt_sfu, "sfu" },
132 { Opt_nosfu, "nosfu" },
133 { Opt_nodfs, "nodfs" },
134 { Opt_posixpaths, "posixpaths" },
135 { Opt_noposixpaths, "noposixpaths" },
136 { Opt_nounix, "nounix" },
137 { Opt_nounix, "nolinux" },
138 { Opt_nocase, "nocase" },
139 { Opt_nocase, "ignorecase" },
140 { Opt_brl, "brl" },
141 { Opt_nobrl, "nobrl" },
142 { Opt_nobrl, "nolock" },
143 { Opt_forcemandatorylock, "forcemandatorylock" },
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +0400144 { Opt_forcemandatorylock, "forcemand" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400145 { Opt_setuids, "setuids" },
146 { Opt_nosetuids, "nosetuids" },
147 { Opt_dynperm, "dynperm" },
148 { Opt_nodynperm, "nodynperm" },
149 { Opt_nohard, "nohard" },
150 { Opt_nosoft, "nosoft" },
151 { Opt_nointr, "nointr" },
152 { Opt_intr, "intr" },
153 { Opt_nostrictsync, "nostrictsync" },
154 { Opt_strictsync, "strictsync" },
155 { Opt_serverino, "serverino" },
156 { Opt_noserverino, "noserverino" },
157 { Opt_rwpidforward, "rwpidforward" },
158 { Opt_cifsacl, "cifsacl" },
159 { Opt_nocifsacl, "nocifsacl" },
160 { Opt_acl, "acl" },
161 { Opt_noacl, "noacl" },
162 { Opt_locallease, "locallease" },
163 { Opt_sign, "sign" },
164 { Opt_seal, "seal" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400165 { Opt_noac, "noac" },
166 { Opt_fsc, "fsc" },
167 { Opt_mfsymlinks, "mfsymlinks" },
168 { Opt_multiuser, "multiuser" },
Jeff Laytond8162552012-03-23 14:40:56 -0400169 { Opt_sloppy, "sloppy" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400170
171 { Opt_backupuid, "backupuid=%s" },
172 { Opt_backupgid, "backupgid=%s" },
173 { Opt_uid, "uid=%s" },
174 { Opt_cruid, "cruid=%s" },
175 { Opt_gid, "gid=%s" },
176 { Opt_file_mode, "file_mode=%s" },
177 { Opt_dirmode, "dirmode=%s" },
178 { Opt_dirmode, "dir_mode=%s" },
179 { Opt_port, "port=%s" },
180 { Opt_rsize, "rsize=%s" },
181 { Opt_wsize, "wsize=%s" },
182 { Opt_actimeo, "actimeo=%s" },
183
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100184 { Opt_blank_user, "user=" },
185 { Opt_blank_user, "username=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400186 { Opt_user, "user=%s" },
187 { Opt_user, "username=%s" },
188 { Opt_blank_pass, "pass=" },
Jesper Nilsson3c15b4c2012-11-29 17:31:16 +0100189 { Opt_blank_pass, "password=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400190 { Opt_pass, "pass=%s" },
191 { Opt_pass, "password=%s" },
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100192 { Opt_blank_ip, "ip=" },
193 { Opt_blank_ip, "addr=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400194 { Opt_ip, "ip=%s" },
195 { Opt_ip, "addr=%s" },
196 { Opt_unc, "unc=%s" },
197 { Opt_unc, "target=%s" },
198 { Opt_unc, "path=%s" },
199 { Opt_domain, "dom=%s" },
200 { Opt_domain, "domain=%s" },
201 { Opt_domain, "workgroup=%s" },
202 { Opt_srcaddr, "srcaddr=%s" },
203 { Opt_prefixpath, "prefixpath=%s" },
204 { Opt_iocharset, "iocharset=%s" },
205 { Opt_sockopt, "sockopt=%s" },
206 { Opt_netbiosname, "netbiosname=%s" },
207 { Opt_servern, "servern=%s" },
208 { Opt_ver, "ver=%s" },
Jeff Layton23db65f2012-05-15 12:20:51 -0400209 { Opt_vers, "vers=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400210 { Opt_sec, "sec=%s" },
Jeff Layton15b6a472012-05-16 07:50:15 -0400211 { Opt_cache, "cache=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400212
213 { Opt_ignore, "cred" },
214 { Opt_ignore, "credentials" },
Jeff Laytona557b972012-05-02 14:02:40 -0400215 { Opt_ignore, "cred=%s" },
216 { Opt_ignore, "credentials=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400217 { Opt_ignore, "guest" },
218 { Opt_ignore, "rw" },
219 { Opt_ignore, "ro" },
220 { Opt_ignore, "suid" },
221 { Opt_ignore, "nosuid" },
222 { Opt_ignore, "exec" },
223 { Opt_ignore, "noexec" },
224 { Opt_ignore, "nodev" },
225 { Opt_ignore, "noauto" },
226 { Opt_ignore, "dev" },
227 { Opt_ignore, "mand" },
228 { Opt_ignore, "nomand" },
229 { Opt_ignore, "_netdev" },
230
231 { Opt_err, NULL }
232};
233
234enum {
235 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
236 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
Jeff Layton76596242012-07-23 20:34:17 -0400237 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
238 Opt_sec_ntlmv2i, Opt_sec_lanman,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400239 Opt_sec_none,
240
241 Opt_sec_err
242};
243
244static const match_table_t cifs_secflavor_tokens = {
245 { Opt_sec_krb5, "krb5" },
246 { Opt_sec_krb5i, "krb5i" },
247 { Opt_sec_krb5p, "krb5p" },
248 { Opt_sec_ntlmsspi, "ntlmsspi" },
249 { Opt_sec_ntlmssp, "ntlmssp" },
250 { Opt_ntlm, "ntlm" },
251 { Opt_sec_ntlmi, "ntlmi" },
Jeff Layton76596242012-07-23 20:34:17 -0400252 { Opt_sec_ntlmv2, "nontlm" },
253 { Opt_sec_ntlmv2, "ntlmv2" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400254 { Opt_sec_ntlmv2i, "ntlmv2i" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400255 { Opt_sec_lanman, "lanman" },
256 { Opt_sec_none, "none" },
257
258 { Opt_sec_err, NULL }
259};
260
Jeff Layton15b6a472012-05-16 07:50:15 -0400261/* cache flavors */
262enum {
263 Opt_cache_loose,
264 Opt_cache_strict,
265 Opt_cache_none,
266 Opt_cache_err
267};
268
269static const match_table_t cifs_cacheflavor_tokens = {
270 { Opt_cache_loose, "loose" },
271 { Opt_cache_strict, "strict" },
272 { Opt_cache_none, "none" },
273 { Opt_cache_err, NULL }
274};
275
Jeff Layton23db65f2012-05-15 12:20:51 -0400276static const match_table_t cifs_smb_version_tokens = {
277 { Smb_1, SMB1_VERSION_STRING },
Steve Frenchdd446b12012-11-28 23:21:06 -0600278 { Smb_20, SMB20_VERSION_STRING},
Steve French1080ef72011-02-24 18:07:19 +0000279 { Smb_21, SMB21_VERSION_STRING },
Steve Frenche4aa25e2012-10-01 12:26:22 -0500280 { Smb_30, SMB30_VERSION_STRING },
Jeff Layton23db65f2012-05-15 12:20:51 -0400281};
282
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300283static int ip_connect(struct TCP_Server_Info *server);
284static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400285static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400286static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -0400287static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
288 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Jeff Laytond5c56052008-12-01 18:42:33 -0500290/*
291 * cifs tcp session reconnection
292 *
293 * mark tcp session as reconnecting so temporarily locked
294 * mark all smb sessions as reconnecting for tcp session
295 * reconnect tcp session
296 * wake up waiters on reconnection? - (not needed currently)
297 */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400298int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299cifs_reconnect(struct TCP_Server_Info *server)
300{
301 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500302 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000303 struct cifs_ses *ses;
304 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000305 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400306 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +0000307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000309 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000310 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 next time through the loop */
312 spin_unlock(&GlobalMid_Lock);
313 return rc;
314 } else
315 server->tcpStatus = CifsNeedReconnect;
316 spin_unlock(&GlobalMid_Lock);
317 server->maxBuf = 0;
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400318#ifdef CONFIG_CIFS_SMB2
319 server->max_read = 0;
320#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Joe Perchesb6b38f72010-04-21 03:50:45 +0000322 cFYI(1, "Reconnecting tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324 /* before reconnecting the tcp session, mark the smb session (uid)
325 and the tid bad so they are not used until reconnected */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500326 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530327 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500328 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000329 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500330 ses->need_reconnect = true;
331 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500332 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000333 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500334 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530337 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 /* do not want to be sending data on a socket we are freeing */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500340 cFYI(1, "%s: tearing down socket", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500341 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000342 if (server->ssocket) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000343 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
344 server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800345 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000346 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000347 server->ssocket->state,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000348 server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 sock_release(server->ssocket);
350 server->ssocket = NULL;
351 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500352 server->sequence_number = 0;
353 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500354 kfree(server->session_key.response);
355 server->session_key.response = NULL;
356 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000357 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500358 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500360 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400361 INIT_LIST_HEAD(&retry_list);
362 cFYI(1, "%s: moving mids to private list", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500364 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
365 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400366 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
367 mid_entry->mid_state = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400368 list_move(&mid_entry->qhead, &retry_list);
369 }
370 spin_unlock(&GlobalMid_Lock);
371
372 cFYI(1, "%s: issuing mid callbacks", __func__);
373 list_for_each_safe(tmp, tmp2, &retry_list) {
374 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500375 list_del_init(&mid_entry->qhead);
376 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400379 do {
Steve French6c3d8902006-07-31 22:46:20 +0000380 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300381
382 /* we should try only the port we connected to before */
383 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000384 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000385 cFYI(1, "reconnect error %d", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700386 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 } else {
388 atomic_inc(&tcpSesReconnectCount);
389 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000390 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000391 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000392 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 }
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400394 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 return rc;
397}
398
Jeff Laytonc74093b2011-01-11 07:24:23 -0500399static void
400cifs_echo_request(struct work_struct *work)
401{
402 int rc;
403 struct TCP_Server_Info *server = container_of(work,
404 struct TCP_Server_Info, echo.work);
405
Jeff Layton247ec9b2011-02-04 17:09:50 -0500406 /*
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400407 * We cannot send an echo if it is disabled or until the
408 * NEGOTIATE_PROTOCOL request is done, which is indicated by
409 * server->ops->need_neg() == true. Also, no need to ping if
410 * we got a response recently.
Jeff Layton247ec9b2011-02-04 17:09:50 -0500411 */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400412 if (!server->ops->need_neg || server->ops->need_neg(server) ||
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400413 (server->ops->can_echo && !server->ops->can_echo(server)) ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500414 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500415 goto requeue_echo;
416
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400417 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500418 if (rc)
419 cFYI(1, "Unable to send echo request to server: %s",
420 server->hostname);
421
422requeue_echo:
Jeff Laytonda472fc2012-03-23 14:40:53 -0400423 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500424}
425
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400426static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400427allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400428{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400429 if (!server->bigbuf) {
430 server->bigbuf = (char *)cifs_buf_get();
431 if (!server->bigbuf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400432 cERROR(1, "No memory for large SMB response");
433 msleep(3000);
434 /* retry will check if exiting */
435 return false;
436 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400437 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400438 /* we are reusing a dirty large buf, clear its start */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400439 memset(server->bigbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400440 }
441
Jeff Layton2a37ef92011-10-19 15:29:23 -0400442 if (!server->smallbuf) {
443 server->smallbuf = (char *)cifs_small_buf_get();
444 if (!server->smallbuf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400445 cERROR(1, "No memory for SMB response");
446 msleep(1000);
447 /* retry will check if exiting */
448 return false;
449 }
450 /* beginning of smb buffer is cleared in our buf_get */
451 } else {
452 /* if existing small buf clear beginning */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400453 memset(server->smallbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400454 }
455
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400456 return true;
457}
458
Jeff Laytonba749e62011-10-11 06:41:32 -0400459static bool
460server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400461{
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300462 /*
463 * We need to wait 2 echo intervals to make sure we handle such
464 * situations right:
465 * 1s client sends a normal SMB request
466 * 2s client gets a response
467 * 30s echo workqueue job pops, and decides we got a response recently
468 * and don't need to send another
469 * ...
470 * 65s kernel_recvmsg times out, and we see that we haven't gotten
471 * a response in >60s.
472 */
473 if (server->tcpStatus == CifsGood &&
474 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
Jeff Laytonba749e62011-10-11 06:41:32 -0400475 cERROR(1, "Server %s has not responded in %d seconds. "
476 "Reconnecting...", server->hostname,
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300477 (2 * SMB_ECHO_INTERVAL) / HZ);
Jeff Laytonba749e62011-10-11 06:41:32 -0400478 cifs_reconnect(server);
479 wake_up(&server->response_q);
480 return true;
481 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400482
Jeff Laytonba749e62011-10-11 06:41:32 -0400483 return false;
484}
485
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400486/*
487 * kvec_array_init - clone a kvec array, and advance into it
488 * @new: pointer to memory for cloned array
489 * @iov: pointer to original array
490 * @nr_segs: number of members in original array
491 * @bytes: number of bytes to advance into the cloned array
492 *
493 * This function will copy the array provided in iov to a section of memory
494 * and advance the specified number of bytes into the new array. It returns
495 * the number of segments in the new array. "new" must be at least as big as
496 * the original iov array.
497 */
498static unsigned int
499kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
500 size_t bytes)
501{
502 size_t base = 0;
503
504 while (bytes || !iov->iov_len) {
505 int copy = min(bytes, iov->iov_len);
506
507 bytes -= copy;
508 base += copy;
509 if (iov->iov_len == base) {
510 iov++;
511 nr_segs--;
512 base = 0;
513 }
514 }
515 memcpy(new, iov, sizeof(*iov) * nr_segs);
516 new->iov_base += base;
517 new->iov_len -= base;
518 return nr_segs;
519}
520
Jeff Layton1041e3f2011-10-19 15:28:27 -0400521static struct kvec *
522get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
523{
524 struct kvec *new_iov;
525
526 if (server->iov && nr_segs <= server->nr_iov)
527 return server->iov;
528
529 /* not big enough -- allocate a new one and release the old */
530 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
531 if (new_iov) {
532 kfree(server->iov);
533 server->iov = new_iov;
534 server->nr_iov = nr_segs;
535 }
536 return new_iov;
537}
538
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400539int
540cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
541 unsigned int nr_segs, unsigned int to_read)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400542{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400543 int length = 0;
544 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400545 unsigned int segs;
Jeff Laytone831e6c2011-10-11 06:41:32 -0400546 struct msghdr smb_msg;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400547 struct kvec *iov;
548
Jeff Layton1041e3f2011-10-19 15:28:27 -0400549 iov = get_server_iovec(server, nr_segs);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400550 if (!iov)
551 return -ENOMEM;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400552
Jeff Laytone831e6c2011-10-11 06:41:32 -0400553 smb_msg.msg_control = NULL;
554 smb_msg.msg_controllen = 0;
555
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400556 for (total_read = 0; to_read; total_read += length, to_read -= length) {
Jeff Layton95edcff2011-12-01 20:22:41 -0500557 try_to_freeze();
558
Jeff Laytonba749e62011-10-11 06:41:32 -0400559 if (server_unresponsive(server)) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400560 total_read = -EAGAIN;
Jeff Laytonba749e62011-10-11 06:41:32 -0400561 break;
562 }
563
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400564 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
565
566 length = kernel_recvmsg(server->ssocket, &smb_msg,
567 iov, segs, to_read, 0);
568
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400569 if (server->tcpStatus == CifsExiting) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400570 total_read = -ESHUTDOWN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400571 break;
572 } else if (server->tcpStatus == CifsNeedReconnect) {
573 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400574 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400575 break;
576 } else if (length == -ERESTARTSYS ||
577 length == -EAGAIN ||
578 length == -EINTR) {
579 /*
580 * Minimum sleep to prevent looping, allowing socket
581 * to clear and app threads to set tcpStatus
582 * CifsNeedReconnect if server hung.
583 */
584 usleep_range(1000, 2000);
585 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400586 continue;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400587 } else if (length <= 0) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400588 cFYI(1, "Received no data or error: expecting %d "
589 "got %d", to_read, length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400590 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400591 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400592 break;
593 }
594 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400595 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400596}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400597
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400598int
599cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
600 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400601{
602 struct kvec iov;
603
604 iov.iov_base = buf;
605 iov.iov_len = to_read;
606
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400607 return cifs_readv_from_socket(server, &iov, 1, to_read);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400608}
609
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400610static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400611is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400612{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400613 /*
614 * The first byte big endian of the length field,
615 * is actually not part of the length but the type
616 * with the most common, zero, as regular data.
617 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400618 switch (type) {
619 case RFC1002_SESSION_MESSAGE:
620 /* Regular SMB response */
621 return true;
622 case RFC1002_SESSION_KEEP_ALIVE:
623 cFYI(1, "RFC 1002 session keep alive");
624 break;
625 case RFC1002_POSITIVE_SESSION_RESPONSE:
626 cFYI(1, "RFC 1002 positive session response");
627 break;
628 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400629 /*
630 * We get this from Windows 98 instead of an error on
631 * SMB negprot response.
632 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400633 cFYI(1, "RFC 1002 negative session response");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400634 /* give server a second to clean up */
635 msleep(1000);
636 /*
637 * Always try 445 first on reconnect since we get NACK
638 * on some if we ever connected to port 139 (the NACK
639 * is since we do not begin with RFC1001 session
640 * initialize frame).
641 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400642 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400643 cifs_reconnect(server);
644 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400645 break;
646 default:
647 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400648 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400649 }
650
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400651 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400652}
653
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400654void
655dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400656{
657#ifdef CONFIG_CIFS_STATS2
658 mid->when_received = jiffies;
659#endif
660 spin_lock(&GlobalMid_Lock);
661 if (!malformed)
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400662 mid->mid_state = MID_RESPONSE_RECEIVED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400663 else
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400664 mid->mid_state = MID_RESPONSE_MALFORMED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400665 list_del_init(&mid->qhead);
666 spin_unlock(&GlobalMid_Lock);
667}
668
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400669static void
670handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400671 char *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400672{
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400673 if (server->ops->check_trans2 &&
674 server->ops->check_trans2(mid, server, buf, malformed))
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400675 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400676 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400677 mid->large_buf = server->large_buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400678 /* Was previous buf put in mpx struct for multi-rsp? */
679 if (!mid->multiRsp) {
680 /* smb buffer will be freed by user thread */
681 if (server->large_buf)
682 server->bigbuf = NULL;
683 else
684 server->smallbuf = NULL;
685 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400686 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400687}
688
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400689static void clean_demultiplex_info(struct TCP_Server_Info *server)
690{
691 int length;
692
693 /* take it off the list, if it's not already */
694 spin_lock(&cifs_tcp_ses_lock);
695 list_del_init(&server->tcp_ses_list);
696 spin_unlock(&cifs_tcp_ses_lock);
697
698 spin_lock(&GlobalMid_Lock);
699 server->tcpStatus = CifsExiting;
700 spin_unlock(&GlobalMid_Lock);
701 wake_up_all(&server->response_q);
702
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400703 /* check if we have blocked requests that need to free */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300704 spin_lock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400705 if (server->credits <= 0)
706 server->credits = 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300707 spin_unlock(&server->req_lock);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400708 /*
709 * Although there should not be any requests blocked on this queue it
710 * can not hurt to be paranoid and try to wake up requests that may
711 * haven been blocked when more than 50 at time were on the wire to the
712 * same server - they now will see the session is in exit state and get
713 * out of SendReceive.
714 */
715 wake_up_all(&server->request_q);
716 /* give those requests time to exit */
717 msleep(125);
718
719 if (server->ssocket) {
720 sock_release(server->ssocket);
721 server->ssocket = NULL;
722 }
723
724 if (!list_empty(&server->pending_mid_q)) {
725 struct list_head dispose_list;
726 struct mid_q_entry *mid_entry;
727 struct list_head *tmp, *tmp2;
728
729 INIT_LIST_HEAD(&dispose_list);
730 spin_lock(&GlobalMid_Lock);
731 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
732 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400733 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
734 mid_entry->mid_state = MID_SHUTDOWN;
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400735 list_move(&mid_entry->qhead, &dispose_list);
736 }
737 spin_unlock(&GlobalMid_Lock);
738
739 /* now walk dispose list and issue callbacks */
740 list_for_each_safe(tmp, tmp2, &dispose_list) {
741 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400742 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400743 list_del_init(&mid_entry->qhead);
744 mid_entry->callback(mid_entry);
745 }
746 /* 1/8th of sec is more than enough time for them to exit */
747 msleep(125);
748 }
749
750 if (!list_empty(&server->pending_mid_q)) {
751 /*
752 * mpx threads have not exited yet give them at least the smb
753 * send timeout time for long ops.
754 *
755 * Due to delays on oplock break requests, we need to wait at
756 * least 45 seconds before giving up on a request getting a
757 * response and going ahead and killing cifsd.
758 */
759 cFYI(1, "Wait for exit from demultiplex thread");
760 msleep(46000);
761 /*
762 * If threads still have not exited they are probably never
763 * coming home not much else we can do but free the memory.
764 */
765 }
766
767 kfree(server->hostname);
Jeff Layton1041e3f2011-10-19 15:28:27 -0400768 kfree(server->iov);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400769 kfree(server);
770
771 length = atomic_dec_return(&tcpSesAllocCount);
772 if (length > 0)
773 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
774 GFP_KERNEL);
775}
776
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400777static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400778standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
779{
780 int length;
781 char *buf = server->smallbuf;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400782 unsigned int pdu_length = get_rfc1002_length(buf);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400783
784 /* make sure this will fit in a large buffer */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400785 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
Jeff Laytone9097ab2011-10-19 15:29:40 -0400786 cERROR(1, "SMB response too long (%u bytes)",
787 pdu_length);
788 cifs_reconnect(server);
789 wake_up(&server->response_q);
790 return -EAGAIN;
791 }
792
793 /* switch to large buffer if too big for a small one */
794 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
795 server->large_buf = true;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400796 memcpy(server->bigbuf, buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400797 buf = server->bigbuf;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400798 }
799
800 /* now read the rest */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400801 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
802 pdu_length - HEADER_SIZE(server) + 1 + 4);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400803 if (length < 0)
804 return length;
805 server->total_read += length;
806
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400807 dump_smb(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400808
809 /*
810 * We know that we received enough to get to the MID as we
811 * checked the pdu_length earlier. Now check to see
812 * if the rest of the header is OK. We borrow the length
813 * var for the rest of the loop to avoid a new stack var.
814 *
815 * 48 bytes is enough to display the header and a little bit
816 * into the payload for debugging purposes.
817 */
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400818 length = server->ops->check_message(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400819 if (length != 0)
820 cifs_dump_mem("Bad SMB: ", buf,
821 min_t(unsigned int, server->total_read, 48));
822
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700823 if (server->ops->is_status_pending &&
824 server->ops->is_status_pending(buf, server, length))
825 return -1;
826
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500827 if (!mid)
828 return length;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400829
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400830 handle_mid(mid, server, buf, length);
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500831 return 0;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400832}
833
834static int
Al Viro7c97c202011-06-21 08:51:28 -0400835cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
837 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400838 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400839 unsigned int pdu_length;
840 char *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 struct task_struct *task_to_wake = NULL;
842 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000845 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400846
847 length = atomic_inc_return(&tcpSesAllocCount);
848 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000849 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
850 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700852 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000853 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700854 if (try_to_freeze())
855 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700856
Jeff Layton2a37ef92011-10-19 15:29:23 -0400857 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400858 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700859
Jeff Layton2a37ef92011-10-19 15:29:23 -0400860 server->large_buf = false;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400861 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000862 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000863
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400864 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400865 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +0000866 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400867 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -0700868
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400869 /*
870 * The right amount was read from socket - 4 bytes,
871 * so we can now interpret the length field.
872 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400873 pdu_length = get_rfc1002_length(buf);
Steve French46810cb2005-04-28 22:41:09 -0700874
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400875 cFYI(1, "RFC1002 header 0x%x", pdu_length);
876 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000877 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700878
Jeff Layton89482a52011-10-19 15:28:57 -0400879 /* make sure we have enough to get to the MID */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400880 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
Jeff Layton89482a52011-10-19 15:28:57 -0400881 cERROR(1, "SMB response too short (%u bytes)",
882 pdu_length);
883 cifs_reconnect(server);
884 wake_up(&server->response_q);
885 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700886 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400887
Jeff Layton89482a52011-10-19 15:28:57 -0400888 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400889 length = cifs_read_from_socket(server, buf + 4,
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400890 HEADER_SIZE(server) - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -0400891 if (length < 0)
892 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400893 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -0400894
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400895 mid_entry = server->ops->find_mid(server, buf);
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400896
Jeff Layton44d22d82011-10-19 15:29:49 -0400897 if (!mid_entry || !mid_entry->receive)
898 length = standard_receive3(server, mid_entry);
899 else
900 length = mid_entry->receive(server, mid_entry);
901
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400902 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700903 continue;
904
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400905 if (server->large_buf)
Jeff Laytone9097ab2011-10-19 15:29:40 -0400906 buf = server->bigbuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700907
Steve Frenchfda35942011-01-20 18:06:34 +0000908 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500909 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -0400910 if (!mid_entry->multiRsp || mid_entry->multiEnd)
911 mid_entry->callback(mid_entry);
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400912 } else if (!server->ops->is_oplock_break ||
913 !server->ops->is_oplock_break(buf, server)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000914 cERROR(1, "No task to wake, unknown frame received! "
Jeff Layton80975312011-01-11 07:24:02 -0500915 "NumMids %d", atomic_read(&midCount));
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400916 cifs_dump_mem("Received Data is: ", buf,
917 HEADER_SIZE(server));
Steve French39798772006-05-31 22:40:51 +0000918#ifdef CONFIG_CIFS_DEBUG2
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400919 if (server->ops->dump_detail)
920 server->ops->dump_detail(buf);
Steve French39798772006-05-31 22:40:51 +0000921 cifs_dump_mids(server);
922#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000923
Steve Frenche4eb2952005-04-28 22:41:09 -0700924 }
925 } /* end while !EXITING */
926
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800927 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400928 cifs_buf_release(server->bigbuf);
929 if (server->smallbuf) /* no sense logging a debug message if NULL */
930 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400932 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400933 clean_demultiplex_info(server);
Steve French50c2f752007-07-13 00:33:32 +0000934
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400935 /* if server->tsk was NULL then wait for a signal before exiting */
936 if (!task_to_wake) {
937 set_current_state(TASK_INTERRUPTIBLE);
938 while (!signal_pending(current)) {
939 schedule();
940 set_current_state(TASK_INTERRUPTIBLE);
941 }
942 set_current_state(TASK_RUNNING);
943 }
944
Jeff Layton0468a2c2008-12-01 07:09:35 -0500945 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946}
947
Jeff Laytonc359cf32007-11-16 22:22:06 +0000948/* extract the host portion of the UNC string */
949static char *
950extract_hostname(const char *unc)
951{
952 const char *src;
953 char *dst, *delim;
954 unsigned int len;
955
956 /* skip double chars at beginning of string */
957 /* BB: check validity of these bytes? */
958 src = unc + 2;
959
960 /* delimiter between hostname and sharename is always '\\' now */
961 delim = strchr(src, '\\');
962 if (!delim)
963 return ERR_PTR(-EINVAL);
964
965 len = delim - src;
966 dst = kmalloc((len + 1), GFP_KERNEL);
967 if (dst == NULL)
968 return ERR_PTR(-ENOMEM);
969
970 memcpy(dst, src, len);
971 dst[len] = '\0';
972
973 return dst;
974}
975
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400976static int get_option_ul(substring_t args[], unsigned long *option)
977{
978 int rc;
979 char *string;
980
981 string = match_strdup(args);
982 if (string == NULL)
983 return -ENOMEM;
Sachin Prabhubfa890a2012-04-13 14:04:32 +0100984 rc = kstrtoul(string, 0, option);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400985 kfree(string);
986
987 return rc;
988}
989
990
991static int cifs_parse_security_flavors(char *value,
992 struct smb_vol *vol)
993{
994
995 substring_t args[MAX_OPT_ARGS];
996
997 switch (match_token(value, cifs_secflavor_tokens, args)) {
998 case Opt_sec_krb5:
999 vol->secFlg |= CIFSSEC_MAY_KRB5;
1000 break;
1001 case Opt_sec_krb5i:
1002 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1003 break;
1004 case Opt_sec_krb5p:
1005 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1006 cERROR(1, "Krb5 cifs privacy not supported");
1007 break;
1008 case Opt_sec_ntlmssp:
1009 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1010 break;
1011 case Opt_sec_ntlmsspi:
1012 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1013 break;
1014 case Opt_ntlm:
1015 /* ntlm is default so can be turned off too */
1016 vol->secFlg |= CIFSSEC_MAY_NTLM;
1017 break;
1018 case Opt_sec_ntlmi:
1019 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1020 break;
Jeff Layton76596242012-07-23 20:34:17 -04001021 case Opt_sec_ntlmv2:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001022 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1023 break;
1024 case Opt_sec_ntlmv2i:
1025 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1026 break;
1027#ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman:
1029 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1030 break;
1031#endif
1032 case Opt_sec_none:
1033 vol->nullauth = 1;
1034 break;
1035 default:
1036 cERROR(1, "bad security option: %s", value);
1037 return 1;
1038 }
1039
1040 return 0;
1041}
1042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043static int
Jeff Layton15b6a472012-05-16 07:50:15 -04001044cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1045{
1046 substring_t args[MAX_OPT_ARGS];
1047
1048 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049 case Opt_cache_loose:
1050 vol->direct_io = false;
1051 vol->strict_io = false;
1052 break;
1053 case Opt_cache_strict:
1054 vol->direct_io = false;
1055 vol->strict_io = true;
1056 break;
1057 case Opt_cache_none:
1058 vol->direct_io = true;
1059 vol->strict_io = false;
1060 break;
1061 default:
1062 cERROR(1, "bad cache= option: %s", value);
1063 return 1;
1064 }
1065 return 0;
1066}
1067
1068static int
Jeff Layton23db65f2012-05-15 12:20:51 -04001069cifs_parse_smb_version(char *value, struct smb_vol *vol)
1070{
1071 substring_t args[MAX_OPT_ARGS];
1072
1073 switch (match_token(value, cifs_smb_version_tokens, args)) {
1074 case Smb_1:
1075 vol->ops = &smb1_operations;
1076 vol->vals = &smb1_values;
1077 break;
Steve French1080ef72011-02-24 18:07:19 +00001078#ifdef CONFIG_CIFS_SMB2
Steve Frenchdd446b12012-11-28 23:21:06 -06001079 case Smb_20:
1080 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1081 vol->vals = &smb20_values;
1082 break;
Steve French1080ef72011-02-24 18:07:19 +00001083 case Smb_21:
1084 vol->ops = &smb21_operations;
1085 vol->vals = &smb21_values;
1086 break;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001087 case Smb_30:
Steve French38107d42012-12-08 22:08:06 -06001088 vol->ops = &smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001089 vol->vals = &smb30_values;
1090 break;
Steve French1080ef72011-02-24 18:07:19 +00001091#endif
Jeff Layton23db65f2012-05-15 12:20:51 -04001092 default:
1093 cERROR(1, "Unknown vers= option specified: %s", value);
1094 return 1;
1095 }
1096 return 0;
1097}
1098
Jeff Laytond387a5c2012-12-10 06:10:46 -05001099/*
1100 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1101 * fields with the result. Returns 0 on success and an error otherwise.
1102 */
1103static int
1104cifs_parse_devname(const char *devname, struct smb_vol *vol)
1105{
1106 char *pos;
1107 const char *delims = "/\\";
1108 size_t len;
1109
1110 /* make sure we have a valid UNC double delimiter prefix */
1111 len = strspn(devname, delims);
1112 if (len != 2)
1113 return -EINVAL;
1114
1115 /* find delimiter between host and sharename */
1116 pos = strpbrk(devname + 2, delims);
1117 if (!pos)
1118 return -EINVAL;
1119
1120 /* skip past delimiter */
1121 ++pos;
1122
1123 /* now go until next delimiter or end of string */
1124 len = strcspn(pos, delims);
1125
1126 /* move "pos" up to delimiter or NULL */
1127 pos += len;
1128 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1129 if (!vol->UNC)
1130 return -ENOMEM;
1131
1132 convert_delimiter(vol->UNC, '\\');
1133
1134 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1135 if (!*pos++ || !*pos)
1136 return 0;
1137
1138 vol->prepath = kstrdup(pos, GFP_KERNEL);
1139 if (!vol->prepath)
1140 return -ENOMEM;
1141
1142 return 0;
1143}
1144
Jeff Layton23db65f2012-05-15 12:20:51 -04001145static int
Sean Finneyb9468452011-04-11 13:19:32 +00001146cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +00001147 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001149 char *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +04001150 char *mountdata_copy = NULL, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 unsigned int temp_len, i, j;
1152 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001153 short int override_uid = -1;
1154 short int override_gid = -1;
1155 bool uid_specified = false;
1156 bool gid_specified = false;
Jeff Laytond8162552012-03-23 14:40:56 -04001157 bool sloppy = false;
1158 char *invalid = NULL;
Jeff Layton88463992010-11-22 15:31:03 -05001159 char *nodename = utsname()->nodename;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001160 char *string = NULL;
1161 char *tmp_end, *value;
1162 char delim;
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001163 bool got_ip = false;
1164 unsigned short port = 0;
1165 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
1167 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +00001168 separator[1] = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001169 delim = separator[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
Jeff Layton6ee95422012-11-26 11:09:57 -05001171 /* ensure we always start with zeroed-out smb_vol */
1172 memset(vol, 0, sizeof(*vol));
1173
Jeff Layton88463992010-11-22 15:31:03 -05001174 /*
1175 * does not have to be perfect mapping since field is
1176 * informational, only used for servers that do not support
1177 * port 445 and it can be overridden at mount time
1178 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001179 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1180 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -05001181 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1182
Jeff Layton1397f2e2011-01-07 11:30:28 -05001183 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -07001184 /* null target name indicates to use *SMBSERVR default called name
1185 if we end up sending RFC1001 session initialize */
1186 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001187 vol->cred_uid = current_uid();
1188 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +11001189 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001190
1191 /* default to only allowing write access to owner of the mount */
1192 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
1194 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -07001195 /* default is always to request posix paths. */
1196 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -04001197 /* default to using server inode numbers where available */
1198 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001199
Jeff Layton1b359202012-09-19 15:20:27 -07001200 /* default is to use strict cifs caching semantics */
1201 vol->strict_io = true;
1202
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301203 vol->actimeo = CIFS_DEF_ACTIMEO;
1204
Jeff Layton23db65f2012-05-15 12:20:51 -04001205 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1206 vol->ops = &smb1_operations;
1207 vol->vals = &smb1_values;
1208
Sean Finneyb9468452011-04-11 13:19:32 +00001209 if (!mountdata)
1210 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
Sean Finneyb9468452011-04-11 13:19:32 +00001212 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1213 if (!mountdata_copy)
1214 goto cifs_parse_mount_err;
1215
1216 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001217 end = options + strlen(options);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001218
Steve French50c2f752007-07-13 00:33:32 +00001219 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001220 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 separator[0] = options[4];
1222 options += 5;
1223 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001224 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 }
1226 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001227 vol->backupuid_specified = false; /* no backup intent for a user */
1228 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +00001229
Jeff Laytond387a5c2012-12-10 06:10:46 -05001230 /*
1231 * For now, we ignore -EINVAL errors under the assumption that the
1232 * unc= and prefixpath= options will be usable.
1233 */
1234 if (cifs_parse_devname(devname, vol) == -ENOMEM) {
1235 printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
1236 "device string.\n");
1237 goto out_nomem;
1238 }
1239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 while ((data = strsep(&options, separator)) != NULL) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001241 substring_t args[MAX_OPT_ARGS];
1242 unsigned long option;
1243 int token;
1244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 if (!*data)
1246 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001248 token = match_token(data, cifs_mount_option_tokens, args);
1249
1250 switch (token) {
1251
1252 /* Ingnore the following */
1253 case Opt_ignore:
1254 break;
1255
1256 /* Boolean values */
1257 case Opt_user_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 vol->no_xattr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001259 break;
1260 case Opt_nouser_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 vol->no_xattr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001262 break;
1263 case Opt_forceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001264 override_uid = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001265 break;
1266 case Opt_noforceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001267 override_uid = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001268 break;
Jeff Layton72bd4812012-10-03 16:02:36 -04001269 case Opt_forcegid:
1270 override_gid = 1;
1271 break;
1272 case Opt_noforcegid:
1273 override_gid = 0;
1274 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001275 case Opt_noblocksend:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001276 vol->noblocksnd = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001277 break;
1278 case Opt_noautotune:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001279 vol->noautotune = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001280 break;
1281 case Opt_hard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001283 break;
1284 case Opt_soft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001286 break;
1287 case Opt_perm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 vol->noperm = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001289 break;
1290 case Opt_noperm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 vol->noperm = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001292 break;
1293 case Opt_mapchars:
Steve French6a0b4822005-04-28 22:41:05 -07001294 vol->remap = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001295 break;
1296 case Opt_nomapchars:
Steve French6a0b4822005-04-28 22:41:05 -07001297 vol->remap = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001298 break;
1299 case Opt_sfu:
Steve French50c2f752007-07-13 00:33:32 +00001300 vol->sfu_emul = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001301 break;
1302 case Opt_nosfu:
Steve French50c2f752007-07-13 00:33:32 +00001303 vol->sfu_emul = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001304 break;
1305 case Opt_nodfs:
Steve French2c1b8612008-10-16 18:35:21 +00001306 vol->nodfs = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001307 break;
1308 case Opt_posixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001309 vol->posix_paths = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001310 break;
1311 case Opt_noposixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001312 vol->posix_paths = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001313 break;
1314 case Opt_nounix:
Steve Frenchc18c8422007-07-18 23:21:09 +00001315 vol->no_linux_ext = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001316 break;
1317 case Opt_nocase:
Steve French50c2f752007-07-13 00:33:32 +00001318 vol->nocase = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001319 break;
1320 case Opt_brl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001321 vol->nobrl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001322 break;
1323 case Opt_nobrl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001324 vol->nobrl = 1;
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001325 /*
1326 * turn off mandatory locking in mode
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001327 * if remote locking is turned off since the
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001328 * local vfs will do advisory
1329 */
Steve French50c2f752007-07-13 00:33:32 +00001330 if (vol->file_mode ==
1331 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001332 vol->file_mode = S_IALLUGO;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001333 break;
1334 case Opt_forcemandatorylock:
Steve French13a6e422008-12-02 17:24:33 +00001335 vol->mand_lock = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001336 break;
1337 case Opt_setuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 vol->setuids = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001339 break;
1340 case Opt_nosetuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 vol->setuids = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001342 break;
1343 case Opt_dynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001344 vol->dynperm = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001345 break;
1346 case Opt_nodynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001347 vol->dynperm = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001348 break;
1349 case Opt_nohard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001351 break;
1352 case Opt_nosoft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001354 break;
1355 case Opt_nointr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 vol->intr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001357 break;
1358 case Opt_intr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 vol->intr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001360 break;
1361 case Opt_nostrictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001362 vol->nostrictsync = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001363 break;
1364 case Opt_strictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001365 vol->nostrictsync = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001366 break;
1367 case Opt_serverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 vol->server_ino = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001369 break;
1370 case Opt_noserverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 vol->server_ino = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001372 break;
1373 case Opt_rwpidforward:
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001374 vol->rwpidforward = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001375 break;
1376 case Opt_cifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001377 vol->cifs_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001378 break;
1379 case Opt_nocifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001380 vol->cifs_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001381 break;
1382 case Opt_acl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 vol->no_psx_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001384 break;
1385 case Opt_noacl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 vol->no_psx_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001387 break;
1388 case Opt_locallease:
Steve French84210e92008-10-23 04:42:37 +00001389 vol->local_lease = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001390 break;
1391 case Opt_sign:
Steve French750d1152006-06-27 06:28:30 +00001392 vol->secFlg |= CIFSSEC_MUST_SIGN;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001393 break;
1394 case Opt_seal:
Steve French95b1cb92008-05-15 16:44:38 +00001395 /* we do not do the following in secFlags because seal
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001396 * is a per tree connection (mount) not a per socket
1397 * or per-smb connection option in the protocol
1398 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1399 */
Steve French95b1cb92008-05-15 16:44:38 +00001400 vol->seal = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001401 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001402 case Opt_noac:
Steve French50c2f752007-07-13 00:33:32 +00001403 printk(KERN_WARNING "CIFS: Mount option noac not "
1404 "supported. Instead set "
1405 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001406 break;
1407 case Opt_fsc:
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301408#ifndef CONFIG_CIFS_FSCACHE
Jeff Layton83fb0862011-06-08 07:35:24 -04001409 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301410 "kernel config option set");
Sean Finneyb9468452011-04-11 13:19:32 +00001411 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301412#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301413 vol->fsc = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001414 break;
1415 case Opt_mfsymlinks:
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001416 vol->mfsymlinks = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001417 break;
1418 case Opt_multiuser:
Jeff Layton0eb8a132010-10-06 19:51:12 -04001419 vol->multiuser = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001420 break;
Jeff Laytond8162552012-03-23 14:40:56 -04001421 case Opt_sloppy:
1422 sloppy = true;
1423 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001424
1425 /* Numeric Values */
1426 case Opt_backupuid:
1427 if (get_option_ul(args, &option)) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001428 cERROR(1, "%s: Invalid backupuid value",
1429 __func__);
1430 goto cifs_parse_mount_err;
1431 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001432 vol->backupuid = option;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001433 vol->backupuid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001434 break;
1435 case Opt_backupgid:
1436 if (get_option_ul(args, &option)) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001437 cERROR(1, "%s: Invalid backupgid value",
1438 __func__);
1439 goto cifs_parse_mount_err;
1440 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001441 vol->backupgid = option;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001442 vol->backupgid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001443 break;
1444 case Opt_uid:
1445 if (get_option_ul(args, &option)) {
1446 cERROR(1, "%s: Invalid uid value",
1447 __func__);
Sean Finneyb9468452011-04-11 13:19:32 +00001448 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001450 vol->linux_uid = option;
1451 uid_specified = true;
1452 break;
1453 case Opt_cruid:
1454 if (get_option_ul(args, &option)) {
1455 cERROR(1, "%s: Invalid cruid value",
1456 __func__);
1457 goto cifs_parse_mount_err;
1458 }
1459 vol->cred_uid = option;
1460 break;
1461 case Opt_gid:
1462 if (get_option_ul(args, &option)) {
1463 cERROR(1, "%s: Invalid gid value",
1464 __func__);
1465 goto cifs_parse_mount_err;
1466 }
1467 vol->linux_gid = option;
1468 gid_specified = true;
1469 break;
1470 case Opt_file_mode:
1471 if (get_option_ul(args, &option)) {
1472 cERROR(1, "%s: Invalid file_mode value",
1473 __func__);
1474 goto cifs_parse_mount_err;
1475 }
1476 vol->file_mode = option;
1477 break;
1478 case Opt_dirmode:
1479 if (get_option_ul(args, &option)) {
1480 cERROR(1, "%s: Invalid dir_mode value",
1481 __func__);
1482 goto cifs_parse_mount_err;
1483 }
1484 vol->dir_mode = option;
1485 break;
1486 case Opt_port:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001487 if (get_option_ul(args, &option) ||
1488 option > USHRT_MAX) {
1489 cERROR(1, "%s: Invalid port value", __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001490 goto cifs_parse_mount_err;
1491 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001492 port = (unsigned short)option;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001493 break;
1494 case Opt_rsize:
1495 if (get_option_ul(args, &option)) {
1496 cERROR(1, "%s: Invalid rsize value",
1497 __func__);
1498 goto cifs_parse_mount_err;
1499 }
1500 vol->rsize = option;
1501 break;
1502 case Opt_wsize:
1503 if (get_option_ul(args, &option)) {
1504 cERROR(1, "%s: Invalid wsize value",
1505 __func__);
1506 goto cifs_parse_mount_err;
1507 }
1508 vol->wsize = option;
1509 break;
1510 case Opt_actimeo:
1511 if (get_option_ul(args, &option)) {
1512 cERROR(1, "%s: Invalid actimeo value",
1513 __func__);
1514 goto cifs_parse_mount_err;
1515 }
1516 vol->actimeo = HZ * option;
1517 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1518 cERROR(1, "CIFS: attribute cache"
1519 "timeout too large");
1520 goto cifs_parse_mount_err;
1521 }
1522 break;
1523
1524 /* String Arguments */
1525
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001526 case Opt_blank_user:
1527 /* null user, ie. anonymous authentication */
1528 vol->nullauth = 1;
1529 vol->username = NULL;
1530 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001531 case Opt_user:
1532 string = match_strdup(args);
1533 if (string == NULL)
1534 goto out_nomem;
1535
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001536 if (strnlen(string, MAX_USERNAME_SIZE) >
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001537 MAX_USERNAME_SIZE) {
1538 printk(KERN_WARNING "CIFS: username too long\n");
1539 goto cifs_parse_mount_err;
1540 }
1541 vol->username = kstrdup(string, GFP_KERNEL);
1542 if (!vol->username) {
1543 printk(KERN_WARNING "CIFS: no memory "
1544 "for username\n");
1545 goto cifs_parse_mount_err;
1546 }
1547 break;
1548 case Opt_blank_pass:
1549 vol->password = NULL;
1550 break;
1551 case Opt_pass:
1552 /* passwords have to be handled differently
1553 * to allow the character used for deliminator
1554 * to be passed within them
1555 */
1556
1557 /* Obtain the value string */
1558 value = strchr(data, '=');
Sachin Prabhu10238072012-03-28 18:07:08 +01001559 value++;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001560
1561 /* Set tmp_end to end of the string */
1562 tmp_end = (char *) value + strlen(value);
1563
1564 /* Check if following character is the deliminator
1565 * If yes, we have encountered a double deliminator
1566 * reset the NULL character to the deliminator
1567 */
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301568 if (tmp_end < end && tmp_end[1] == delim) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001569 tmp_end[0] = delim;
1570
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301571 /* Keep iterating until we get to a single
1572 * deliminator OR the end
1573 */
1574 while ((tmp_end = strchr(tmp_end, delim))
1575 != NULL && (tmp_end[1] == delim)) {
1576 tmp_end = (char *) &tmp_end[2];
1577 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001578
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301579 /* Reset var options to point to next element */
1580 if (tmp_end) {
1581 tmp_end[0] = '\0';
1582 options = (char *) &tmp_end[1];
1583 } else
1584 /* Reached the end of the mount option
1585 * string */
1586 options = end;
1587 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001588
1589 /* Now build new password string */
1590 temp_len = strlen(value);
1591 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1592 if (vol->password == NULL) {
1593 printk(KERN_WARNING "CIFS: no memory "
1594 "for password\n");
1595 goto cifs_parse_mount_err;
1596 }
1597
1598 for (i = 0, j = 0; i < temp_len; i++, j++) {
1599 vol->password[j] = value[i];
1600 if ((value[i] == delim) &&
1601 value[i+1] == delim)
1602 /* skip the second deliminator */
1603 i++;
1604 }
1605 vol->password[j] = '\0';
1606 break;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001607 case Opt_blank_ip:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001608 /* FIXME: should this be an error instead? */
1609 got_ip = false;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001610 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001611 case Opt_ip:
1612 string = match_strdup(args);
1613 if (string == NULL)
1614 goto out_nomem;
1615
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001616 if (!cifs_convert_address(dstaddr, string,
1617 strlen(string))) {
1618 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1619 string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001620 goto cifs_parse_mount_err;
1621 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001622 got_ip = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001623 break;
1624 case Opt_unc:
Jeff Laytond387a5c2012-12-10 06:10:46 -05001625 string = vol->UNC;
Jeff Layton62a1a432012-12-10 06:10:45 -05001626 vol->UNC = match_strdup(args);
Jeff Layton83672242012-12-13 06:02:51 -05001627 if (vol->UNC == NULL)
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001628 goto out_nomem;
1629
Jeff Layton62a1a432012-12-10 06:10:45 -05001630 convert_delimiter(vol->UNC, '\\');
1631 if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
Jeff Laytond387a5c2012-12-10 06:10:46 -05001632 printk(KERN_ERR "CIFS: UNC Path does not "
Jeff Layton62a1a432012-12-10 06:10:45 -05001633 "begin with // or \\\\\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001634 goto cifs_parse_mount_err;
1635 }
1636
Jeff Laytond387a5c2012-12-10 06:10:46 -05001637 /* Compare old unc= option to new one */
1638 if (!string || strcmp(string, vol->UNC))
1639 printk(KERN_WARNING "CIFS: the value of the "
1640 "unc= mount option does not match the "
1641 "device string. Using the unc= option "
1642 "for now. In 3.10, that option will "
1643 "be ignored and the contents of the "
1644 "device string will be used "
1645 "instead. (%s != %s)\n", string,
1646 vol->UNC);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001647 break;
1648 case Opt_domain:
1649 string = match_strdup(args);
1650 if (string == NULL)
1651 goto out_nomem;
1652
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001653 if (strnlen(string, 256) == 256) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001654 printk(KERN_WARNING "CIFS: domain name too"
1655 " long\n");
1656 goto cifs_parse_mount_err;
1657 }
1658
1659 vol->domainname = kstrdup(string, GFP_KERNEL);
1660 if (!vol->domainname) {
1661 printk(KERN_WARNING "CIFS: no memory "
1662 "for domainname\n");
1663 goto cifs_parse_mount_err;
1664 }
1665 cFYI(1, "Domain name set");
1666 break;
1667 case Opt_srcaddr:
1668 string = match_strdup(args);
1669 if (string == NULL)
1670 goto out_nomem;
1671
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001672 if (!cifs_convert_address(
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001673 (struct sockaddr *)&vol->srcaddr,
1674 string, strlen(string))) {
1675 printk(KERN_WARNING "CIFS: Could not parse"
1676 " srcaddr: %s\n", string);
1677 goto cifs_parse_mount_err;
1678 }
1679 break;
1680 case Opt_prefixpath:
Jeff Layton839db3d2012-12-10 06:10:45 -05001681 /* skip over any leading delimiter */
1682 if (*args[0].from == '/' || *args[0].from == '\\')
1683 args[0].from++;
1684
Jeff Laytond387a5c2012-12-10 06:10:46 -05001685 string = vol->prepath;
Jeff Layton839db3d2012-12-10 06:10:45 -05001686 vol->prepath = match_strdup(args);
Jeff Layton83672242012-12-13 06:02:51 -05001687 if (vol->prepath == NULL)
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001688 goto out_nomem;
Jeff Laytond387a5c2012-12-10 06:10:46 -05001689 /* Compare old prefixpath= option to new one */
1690 if (!string || strcmp(string, vol->prepath))
1691 printk(KERN_WARNING "CIFS: the value of the "
1692 "prefixpath= mount option does not "
1693 "match the device string. Using the "
1694 "prefixpath= option for now. In 3.10, "
1695 "that option will be ignored and the "
1696 "contents of the device string will be "
1697 "used instead.(%s != %s)\n", string,
1698 vol->prepath);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001699 break;
1700 case Opt_iocharset:
1701 string = match_strdup(args);
1702 if (string == NULL)
1703 goto out_nomem;
1704
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001705 if (strnlen(string, 1024) >= 65) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001706 printk(KERN_WARNING "CIFS: iocharset name "
1707 "too long.\n");
1708 goto cifs_parse_mount_err;
1709 }
1710
1711 if (strnicmp(string, "default", 7) != 0) {
1712 vol->iocharset = kstrdup(string,
1713 GFP_KERNEL);
1714 if (!vol->iocharset) {
1715 printk(KERN_WARNING "CIFS: no memory"
1716 "for charset\n");
1717 goto cifs_parse_mount_err;
1718 }
1719 }
1720 /* if iocharset not set then load_nls_default
1721 * is used by caller
1722 */
1723 cFYI(1, "iocharset set to %s", string);
1724 break;
1725 case Opt_sockopt:
1726 string = match_strdup(args);
1727 if (string == NULL)
1728 goto out_nomem;
1729
Jeff Layton67c1f522012-09-18 16:20:36 -07001730 if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1731 printk(KERN_WARNING "CIFS: the "
1732 "sockopt=TCP_NODELAY option has been "
1733 "deprecated and will be removed "
1734 "in 3.9\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001735 vol->sockopt_tcp_nodelay = 1;
Jeff Layton67c1f522012-09-18 16:20:36 -07001736 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001737 break;
1738 case Opt_netbiosname:
1739 string = match_strdup(args);
1740 if (string == NULL)
1741 goto out_nomem;
1742
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001743 memset(vol->source_rfc1001_name, 0x20,
1744 RFC1001_NAME_LEN);
1745 /*
1746 * FIXME: are there cases in which a comma can
1747 * be valid in workstation netbios name (and
1748 * need special handling)?
1749 */
1750 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1751 /* don't ucase netbiosname for user */
1752 if (string[i] == 0)
1753 break;
1754 vol->source_rfc1001_name[i] = string[i];
1755 }
1756 /* The string has 16th byte zero still from
1757 * set at top of the function
1758 */
1759 if (i == RFC1001_NAME_LEN && string[i] != 0)
1760 printk(KERN_WARNING "CIFS: netbiosname"
1761 " longer than 15 truncated.\n");
1762
1763 break;
1764 case Opt_servern:
1765 /* servernetbiosname specified override *SMBSERVER */
1766 string = match_strdup(args);
1767 if (string == NULL)
1768 goto out_nomem;
1769
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001770 /* last byte, type, is 0x20 for servr type */
1771 memset(vol->target_rfc1001_name, 0x20,
1772 RFC1001_NAME_LEN_WITH_NULL);
1773
1774 /* BB are there cases in which a comma can be
1775 valid in this workstation netbios name
1776 (and need special handling)? */
1777
1778 /* user or mount helper must uppercase the
1779 netbios name */
1780 for (i = 0; i < 15; i++) {
1781 if (string[i] == 0)
1782 break;
1783 vol->target_rfc1001_name[i] = string[i];
1784 }
1785 /* The string has 16th byte zero still from
1786 set at top of the function */
1787 if (i == RFC1001_NAME_LEN && string[i] != 0)
1788 printk(KERN_WARNING "CIFS: server net"
1789 "biosname longer than 15 truncated.\n");
1790 break;
1791 case Opt_ver:
1792 string = match_strdup(args);
1793 if (string == NULL)
1794 goto out_nomem;
1795
Jeff Layton5249af32012-05-15 12:04:03 -04001796 if (strnicmp(string, "1", 1) == 0) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001797 /* This is the default */
1798 break;
1799 }
1800 /* For all other value, error */
1801 printk(KERN_WARNING "CIFS: Invalid version"
1802 " specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001803 goto cifs_parse_mount_err;
Jeff Layton23db65f2012-05-15 12:20:51 -04001804 case Opt_vers:
1805 string = match_strdup(args);
1806 if (string == NULL)
1807 goto out_nomem;
1808
1809 if (cifs_parse_smb_version(string, vol) != 0)
1810 goto cifs_parse_mount_err;
1811 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001812 case Opt_sec:
1813 string = match_strdup(args);
1814 if (string == NULL)
1815 goto out_nomem;
1816
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001817 if (cifs_parse_security_flavors(string, vol) != 0)
1818 goto cifs_parse_mount_err;
1819 break;
Jeff Layton15b6a472012-05-16 07:50:15 -04001820 case Opt_cache:
1821 string = match_strdup(args);
1822 if (string == NULL)
1823 goto out_nomem;
1824
1825 if (cifs_parse_cache_flavor(string, vol) != 0)
1826 goto cifs_parse_mount_err;
1827 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001828 default:
Jeff Laytond8162552012-03-23 14:40:56 -04001829 /*
1830 * An option we don't recognize. Save it off for later
1831 * if we haven't already found one
1832 */
1833 if (!invalid)
1834 invalid = data;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001835 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001837 /* Free up any allocated string */
1838 kfree(string);
1839 string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001841
Jeff Laytond8162552012-03-23 14:40:56 -04001842 if (!sloppy && invalid) {
1843 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1844 goto cifs_parse_mount_err;
1845 }
1846
Jeff Layton8a8798a2012-01-17 16:09:15 -05001847#ifndef CONFIG_KEYS
1848 /* Muliuser mounts require CONFIG_KEYS support */
1849 if (vol->multiuser) {
1850 cERROR(1, "Multiuser mounts require kernels with "
1851 "CONFIG_KEYS enabled.");
Sean Finneyb9468452011-04-11 13:19:32 +00001852 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001853 }
Jeff Layton8a8798a2012-01-17 16:09:15 -05001854#endif
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001855 if (!vol->UNC) {
Jeff Laytond387a5c2012-12-10 06:10:46 -05001856 cERROR(1, "CIFS mount error: No usable UNC path provided in "
1857 "device string or in unc= option!");
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001858 goto cifs_parse_mount_err;
1859 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001860
Jeff Layton62a1a432012-12-10 06:10:45 -05001861 /* make sure UNC has a share name */
1862 if (!strchr(vol->UNC + 3, '\\')) {
1863 cERROR(1, "Malformed UNC. Unable to find share name.");
1864 goto cifs_parse_mount_err;
1865 }
1866
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001867 if (!got_ip) {
1868 /* No ip= option specified? Try to get it from UNC */
1869 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1870 strlen(&vol->UNC[2]))) {
1871 printk(KERN_ERR "Unable to determine destination "
1872 "address.\n");
1873 goto cifs_parse_mount_err;
1874 }
1875 }
1876
1877 /* set the port that we got earlier */
1878 cifs_set_port(dstaddr, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001880 if (uid_specified)
1881 vol->override_uid = override_uid;
1882 else if (override_uid == 1)
1883 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1884 "specified with no uid= option.\n");
1885
1886 if (gid_specified)
1887 vol->override_gid = override_gid;
1888 else if (override_gid == 1)
1889 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1890 "specified with no gid= option.\n");
1891
Sean Finneyb9468452011-04-11 13:19:32 +00001892 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001894
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001895out_nomem:
1896 printk(KERN_WARNING "Could not allocate temporary buffer\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001897cifs_parse_mount_err:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001898 kfree(string);
Sean Finneyb9468452011-04-11 13:19:32 +00001899 kfree(mountdata_copy);
1900 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901}
1902
Ben Greear3eb9a882010-09-01 17:06:02 -07001903/** Returns true if srcaddr isn't specified and rhs isn't
1904 * specified, or if srcaddr is specified and
1905 * matches the IP address of the rhs argument.
1906 */
Jeff Layton45151482010-07-06 20:43:02 -04001907static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001908srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1909{
1910 switch (srcaddr->sa_family) {
1911 case AF_UNSPEC:
1912 return (rhs->sa_family == AF_UNSPEC);
1913 case AF_INET: {
1914 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1915 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1916 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1917 }
1918 case AF_INET6: {
1919 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1920 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1921 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1922 }
1923 default:
1924 WARN_ON(1);
1925 return false; /* don't expect to be here */
1926 }
1927}
1928
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001929/*
1930 * If no port is specified in addr structure, we try to match with 445 port
1931 * and if it fails - with 139 ports. It should be called only if address
1932 * families of server and addr are equal.
1933 */
1934static bool
1935match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1936{
Steve French6da97912011-03-13 18:55:55 +00001937 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001938
1939 switch (addr->sa_family) {
1940 case AF_INET:
1941 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1942 port = ((struct sockaddr_in *) addr)->sin_port;
1943 break;
1944 case AF_INET6:
1945 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1946 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1947 break;
1948 default:
1949 WARN_ON(1);
1950 return false;
1951 }
1952
1953 if (!port) {
1954 port = htons(CIFS_PORT);
1955 if (port == *sport)
1956 return true;
1957
1958 port = htons(RFC1001_PORT);
1959 }
1960
1961 return port == *sport;
1962}
Ben Greear3eb9a882010-09-01 17:06:02 -07001963
1964static bool
1965match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1966 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967{
Jeff Layton45151482010-07-06 20:43:02 -04001968 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001969 case AF_INET: {
1970 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1971 struct sockaddr_in *srv_addr4 =
1972 (struct sockaddr_in *)&server->dstaddr;
1973
1974 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001975 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001976 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001977 }
1978 case AF_INET6: {
1979 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1980 struct sockaddr_in6 *srv_addr6 =
1981 (struct sockaddr_in6 *)&server->dstaddr;
1982
Jeff Layton45151482010-07-06 20:43:02 -04001983 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001984 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001985 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001986 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001987 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001988 break;
1989 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001990 default:
1991 WARN_ON(1);
1992 return false; /* don't expect to be here */
1993 }
Jeff Layton45151482010-07-06 20:43:02 -04001994
Ben Greear3eb9a882010-09-01 17:06:02 -07001995 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1996 return false;
1997
Jeff Layton45151482010-07-06 20:43:02 -04001998 return true;
1999}
2000
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002001static bool
2002match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2003{
2004 unsigned int secFlags;
2005
2006 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2007 secFlags = vol->secFlg;
2008 else
2009 secFlags = global_secflags | vol->secFlg;
2010
2011 switch (server->secType) {
2012 case LANMAN:
2013 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2014 return false;
2015 break;
2016 case NTLMv2:
2017 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2018 return false;
2019 break;
2020 case NTLM:
2021 if (!(secFlags & CIFSSEC_MAY_NTLM))
2022 return false;
2023 break;
2024 case Kerberos:
2025 if (!(secFlags & CIFSSEC_MAY_KRB5))
2026 return false;
2027 break;
2028 case RawNTLMSSP:
2029 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2030 return false;
2031 break;
2032 default:
2033 /* shouldn't happen */
2034 return false;
2035 }
2036
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002037 /* now check if signing mode is acceptable */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002038 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
Steve French96daf2b2011-05-27 04:34:02 +00002039 (server->sec_mode & SECMODE_SIGN_REQUIRED))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002040 return false;
2041 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
Steve French96daf2b2011-05-27 04:34:02 +00002042 (server->sec_mode &
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002043 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2044 return false;
2045
2046 return true;
2047}
2048
Jeff Layton9fa114f2012-11-26 11:09:57 -05002049static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002050{
Jeff Layton9fa114f2012-11-26 11:09:57 -05002051 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2052
Jeff Layton23db65f2012-05-15 12:20:51 -04002053 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2054 return 0;
2055
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002056 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2057 return 0;
2058
2059 if (!match_address(server, addr,
2060 (struct sockaddr *)&vol->srcaddr))
2061 return 0;
2062
2063 if (!match_port(server, addr))
2064 return 0;
2065
2066 if (!match_security(server, vol))
2067 return 0;
2068
2069 return 1;
2070}
2071
Jeff Layton45151482010-07-06 20:43:02 -04002072static struct TCP_Server_Info *
Jeff Layton9fa114f2012-11-26 11:09:57 -05002073cifs_find_tcp_session(struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04002074{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002075 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302077 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04002078 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Jeff Layton9fa114f2012-11-26 11:09:57 -05002079 if (!match_server(server, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002080 continue;
2081
Jeff Laytone7ddee92008-11-14 13:44:38 -05002082 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302083 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002084 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05002085 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302087 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 return NULL;
2089}
2090
Jeff Layton14fbf502008-11-14 13:53:46 -05002091static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05002092cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002094 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302096 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002097 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302098 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002099 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 }
Steve Frenchdea570e02008-05-06 22:05:51 +00002101
Rob Landleyf1d0c992011-01-22 15:44:05 -06002102 put_net(cifs_net_ns(server));
2103
Jeff Laytone7ddee92008-11-14 13:44:38 -05002104 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302105 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002106
Jeff Laytonc74093b2011-01-11 07:24:23 -05002107 cancel_delayed_work_sync(&server->echo);
2108
Jeff Laytone7ddee92008-11-14 13:44:38 -05002109 spin_lock(&GlobalMid_Lock);
2110 server->tcpStatus = CifsExiting;
2111 spin_unlock(&GlobalMid_Lock);
2112
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002113 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302114 cifs_fscache_release_client_cookie(server);
2115
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05002116 kfree(server->session_key.response);
2117 server->session_key.response = NULL;
2118 server->session_key.len = 0;
2119
Jeff Laytone7ddee92008-11-14 13:44:38 -05002120 task = xchg(&server->tsk, NULL);
2121 if (task)
2122 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123}
2124
Jeff Layton63c038c2008-12-01 18:41:46 -05002125static struct TCP_Server_Info *
2126cifs_get_tcp_session(struct smb_vol *volume_info)
2127{
2128 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Layton63c038c2008-12-01 18:41:46 -05002129 int rc;
2130
Jeff Laytonb979aaa2012-11-26 11:09:55 -05002131 cFYI(1, "UNC: %s", volume_info->UNC);
Jeff Layton63c038c2008-12-01 18:41:46 -05002132
2133 /* see if we already have a matching tcp_ses */
Jeff Layton9fa114f2012-11-26 11:09:57 -05002134 tcp_ses = cifs_find_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002135 if (tcp_ses)
2136 return tcp_ses;
2137
2138 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2139 if (!tcp_ses) {
2140 rc = -ENOMEM;
2141 goto out_err;
2142 }
2143
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002144 rc = cifs_crypto_shash_allocate(tcp_ses);
2145 if (rc) {
2146 cERROR(1, "could not setup hash structures rc %d", rc);
2147 goto out_err;
2148 }
2149
Jeff Layton23db65f2012-05-15 12:20:51 -04002150 tcp_ses->ops = volume_info->ops;
2151 tcp_ses->vals = volume_info->vals;
Rob Landleyf1d0c992011-01-22 15:44:05 -06002152 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05002153 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2154 if (IS_ERR(tcp_ses->hostname)) {
2155 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002156 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002157 }
2158
2159 tcp_ses->noblocksnd = volume_info->noblocksnd;
2160 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00002161 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +03002162 tcp_ses->in_flight = 0;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002163 tcp_ses->credits = 1;
Jeff Layton63c038c2008-12-01 18:41:46 -05002164 init_waitqueue_head(&tcp_ses->response_q);
2165 init_waitqueue_head(&tcp_ses->request_q);
2166 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2167 mutex_init(&tcp_ses->srv_mutex);
2168 memcpy(tcp_ses->workstation_RFC1001_name,
2169 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2170 memcpy(tcp_ses->server_RFC1001_name,
2171 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05002172 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05002173 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00002174 tcp_ses->lstrp = jiffies;
Jeff Layton58fa0152012-05-01 17:41:16 -04002175 spin_lock_init(&tcp_ses->req_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002176 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2177 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002178 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton9fa114f2012-11-26 11:09:57 -05002179 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2180 sizeof(tcp_ses->srcaddr));
2181 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2182 sizeof(tcp_ses->dstaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05002183 /*
2184 * at this point we are the only ones with the pointer
2185 * to the struct since the kernel thread not created yet
2186 * no need to spinlock this init of tcpStatus or srv_count
2187 */
2188 tcp_ses->tcpStatus = CifsNew;
2189 ++tcp_ses->srv_count;
2190
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002191 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05002192 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002193 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002194 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002195 }
2196
2197 /*
2198 * since we're in a cifs function already, we know that
2199 * this will succeed. No need for try_module_get().
2200 */
2201 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04002202 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05002203 tcp_ses, "cifsd");
2204 if (IS_ERR(tcp_ses->tsk)) {
2205 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002206 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05002207 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002208 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002209 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00002210 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05002211
2212 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302213 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002214 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302215 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002216
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302217 cifs_fscache_get_client_cookie(tcp_ses);
2218
Jeff Laytonc74093b2011-01-11 07:24:23 -05002219 /* queue echo request delayed work */
Jeff Laytonda472fc2012-03-23 14:40:53 -04002220 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002221
Jeff Layton63c038c2008-12-01 18:41:46 -05002222 return tcp_ses;
2223
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002224out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002225 cifs_crypto_shash_release(tcp_ses);
2226
Rob Landleyf1d0c992011-01-22 15:44:05 -06002227 put_net(cifs_net_ns(tcp_ses));
2228
Jeff Layton63c038c2008-12-01 18:41:46 -05002229out_err:
2230 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00002231 if (!IS_ERR(tcp_ses->hostname))
2232 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05002233 if (tcp_ses->ssocket)
2234 sock_release(tcp_ses->ssocket);
2235 kfree(tcp_ses);
2236 }
2237 return ERR_PTR(rc);
2238}
2239
Steve French96daf2b2011-05-27 04:34:02 +00002240static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002241{
2242 switch (ses->server->secType) {
2243 case Kerberos:
2244 if (vol->cred_uid != ses->cred_uid)
2245 return 0;
2246 break;
2247 default:
Jeff Layton04febab2012-01-17 16:09:15 -05002248 /* NULL username means anonymous session */
2249 if (ses->user_name == NULL) {
2250 if (!vol->nullauth)
2251 return 0;
2252 break;
2253 }
2254
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002255 /* anything else takes username/password */
Jeff Layton04febab2012-01-17 16:09:15 -05002256 if (strncmp(ses->user_name,
2257 vol->username ? vol->username : "",
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002258 MAX_USERNAME_SIZE))
2259 return 0;
2260 if (strlen(vol->username) != 0 &&
2261 ses->password != NULL &&
2262 strncmp(ses->password,
2263 vol->password ? vol->password : "",
2264 MAX_PASSWORD_SIZE))
2265 return 0;
2266 }
2267 return 1;
2268}
2269
Steve French96daf2b2011-05-27 04:34:02 +00002270static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04002271cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272{
Steve French96daf2b2011-05-27 04:34:02 +00002273 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302275 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002276 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002277 if (!match_session(ses, vol))
2278 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002279 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302280 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002281 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302283 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 return NULL;
2285}
2286
Jeff Layton14fbf502008-11-14 13:53:46 -05002287static void
Steve French96daf2b2011-05-27 04:34:02 +00002288cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002289{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04002290 unsigned int xid;
Jeff Layton14fbf502008-11-14 13:53:46 -05002291 struct TCP_Server_Info *server = ses->server;
2292
Jeff Laytonac3aa2f2012-07-23 13:14:28 -04002293 cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302294 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002295 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302296 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002297 return;
2298 }
2299
2300 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302301 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002302
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04002303 if (ses->status == CifsGood && server->ops->logoff) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002304 xid = get_xid();
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04002305 server->ops->logoff(xid, ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002306 _free_xid(xid);
Jeff Layton14fbf502008-11-14 13:53:46 -05002307 }
2308 sesInfoFree(ses);
2309 cifs_put_tcp_session(server);
2310}
2311
Jeff Layton8a8798a2012-01-17 16:09:15 -05002312#ifdef CONFIG_KEYS
2313
2314/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2315#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2316
2317/* Populate username and pw fields from keyring if possible */
2318static int
2319cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2320{
2321 int rc = 0;
2322 char *desc, *delim, *payload;
2323 ssize_t len;
2324 struct key *key;
2325 struct TCP_Server_Info *server = ses->server;
2326 struct sockaddr_in *sa;
2327 struct sockaddr_in6 *sa6;
2328 struct user_key_payload *upayload;
2329
2330 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2331 if (!desc)
2332 return -ENOMEM;
2333
2334 /* try to find an address key first */
2335 switch (server->dstaddr.ss_family) {
2336 case AF_INET:
2337 sa = (struct sockaddr_in *)&server->dstaddr;
2338 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2339 break;
2340 case AF_INET6:
2341 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2342 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2343 break;
2344 default:
2345 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2346 rc = -EINVAL;
2347 goto out_err;
2348 }
2349
2350 cFYI(1, "%s: desc=%s", __func__, desc);
2351 key = request_key(&key_type_logon, desc, "");
2352 if (IS_ERR(key)) {
2353 if (!ses->domainName) {
2354 cFYI(1, "domainName is NULL");
2355 rc = PTR_ERR(key);
2356 goto out_err;
2357 }
2358
2359 /* didn't work, try to find a domain key */
2360 sprintf(desc, "cifs:d:%s", ses->domainName);
2361 cFYI(1, "%s: desc=%s", __func__, desc);
2362 key = request_key(&key_type_logon, desc, "");
2363 if (IS_ERR(key)) {
2364 rc = PTR_ERR(key);
2365 goto out_err;
2366 }
2367 }
2368
2369 down_read(&key->sem);
2370 upayload = key->payload.data;
2371 if (IS_ERR_OR_NULL(upayload)) {
Jeff Layton4edc53c2012-02-07 06:30:51 -05002372 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002373 goto out_key_put;
2374 }
2375
2376 /* find first : in payload */
2377 payload = (char *)upayload->data;
2378 delim = strnchr(payload, upayload->datalen, ':');
2379 cFYI(1, "payload=%s", payload);
2380 if (!delim) {
2381 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2382 upayload->datalen);
2383 rc = -EINVAL;
2384 goto out_key_put;
2385 }
2386
2387 len = delim - payload;
2388 if (len > MAX_USERNAME_SIZE || len <= 0) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002389 cFYI(1, "Bad value from username search (len=%zd)", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002390 rc = -EINVAL;
2391 goto out_key_put;
2392 }
2393
2394 vol->username = kstrndup(payload, len, GFP_KERNEL);
2395 if (!vol->username) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002396 cFYI(1, "Unable to allocate %zd bytes for username", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002397 rc = -ENOMEM;
2398 goto out_key_put;
2399 }
2400 cFYI(1, "%s: username=%s", __func__, vol->username);
2401
2402 len = key->datalen - (len + 1);
2403 if (len > MAX_PASSWORD_SIZE || len <= 0) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002404 cFYI(1, "Bad len for password search (len=%zd)", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002405 rc = -EINVAL;
2406 kfree(vol->username);
2407 vol->username = NULL;
2408 goto out_key_put;
2409 }
2410
2411 ++delim;
2412 vol->password = kstrndup(delim, len, GFP_KERNEL);
2413 if (!vol->password) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002414 cFYI(1, "Unable to allocate %zd bytes for password", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002415 rc = -ENOMEM;
2416 kfree(vol->username);
2417 vol->username = NULL;
2418 goto out_key_put;
2419 }
2420
2421out_key_put:
2422 up_read(&key->sem);
2423 key_put(key);
2424out_err:
2425 kfree(desc);
2426 cFYI(1, "%s: returning %d", __func__, rc);
2427 return rc;
2428}
2429#else /* ! CONFIG_KEYS */
2430static inline int
2431cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2432 struct cifs_ses *ses __attribute__((unused)))
2433{
2434 return -ENOSYS;
2435}
2436#endif /* CONFIG_KEYS */
2437
Steve French96daf2b2011-05-27 04:34:02 +00002438static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002439cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2440{
Pavel Shilovsky286170a2012-05-25 10:43:58 +04002441 int rc = -ENOMEM;
2442 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002443 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002444 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2445 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002446
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002447 xid = get_xid();
Jeff Layton36988c72010-04-24 07:57:43 -04002448
Jeff Layton4ff67b72010-07-06 20:43:02 -04002449 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002450 if (ses) {
2451 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2452
Jeff Layton36988c72010-04-24 07:57:43 -04002453 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002454 rc = cifs_negotiate_protocol(xid, ses);
2455 if (rc) {
2456 mutex_unlock(&ses->session_mutex);
2457 /* problem -- put our ses reference */
2458 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002459 free_xid(xid);
Jeff Layton198b5682010-04-24 07:57:48 -04002460 return ERR_PTR(rc);
2461 }
Jeff Layton36988c72010-04-24 07:57:43 -04002462 if (ses->need_reconnect) {
2463 cFYI(1, "Session needs reconnect");
2464 rc = cifs_setup_session(xid, ses,
2465 volume_info->local_nls);
2466 if (rc) {
2467 mutex_unlock(&ses->session_mutex);
2468 /* problem -- put our reference */
2469 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002470 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002471 return ERR_PTR(rc);
2472 }
2473 }
2474 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002475
2476 /* existing SMB ses has a server reference already */
2477 cifs_put_tcp_session(server);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002478 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002479 return ses;
2480 }
2481
2482 cFYI(1, "Existing smb sess not found");
2483 ses = sesInfoAlloc();
2484 if (ses == NULL)
2485 goto get_ses_fail;
2486
2487 /* new SMB session uses our server ref */
2488 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002489 if (server->dstaddr.ss_family == AF_INET6)
2490 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002491 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002492 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002493
Steve French8727c8a2011-02-25 01:11:56 -06002494 if (volume_info->username) {
2495 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2496 if (!ses->user_name)
2497 goto get_ses_fail;
2498 }
Jeff Layton36988c72010-04-24 07:57:43 -04002499
2500 /* volume_info->password freed at unmount */
2501 if (volume_info->password) {
2502 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2503 if (!ses->password)
2504 goto get_ses_fail;
2505 }
2506 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002507 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2508 if (!ses->domainName)
2509 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002510 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002511 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002512 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002513
Jeff Layton36988c72010-04-24 07:57:43 -04002514 ses->overrideSecFlg = volume_info->secFlg;
2515
2516 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002517 rc = cifs_negotiate_protocol(xid, ses);
2518 if (!rc)
2519 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002520 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002521 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002522 goto get_ses_fail;
2523
2524 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302525 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002526 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302527 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002528
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002529 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002530 return ses;
2531
2532get_ses_fail:
2533 sesInfoFree(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002534 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002535 return ERR_PTR(rc);
2536}
2537
Steve French96daf2b2011-05-27 04:34:02 +00002538static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002539{
2540 if (tcon->tidStatus == CifsExiting)
2541 return 0;
2542 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2543 return 0;
2544 return 1;
2545}
2546
Steve French96daf2b2011-05-27 04:34:02 +00002547static struct cifs_tcon *
2548cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549{
2550 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002551 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302553 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002554 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002555 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002556 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002557 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002558 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302559 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 return tcon;
2561 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302562 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563 return NULL;
2564}
2565
Jeff Laytonf1987b42008-11-15 11:12:47 -05002566static void
Steve French96daf2b2011-05-27 04:34:02 +00002567cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002568{
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002569 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002570 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002571
Jeff Laytonac3aa2f2012-07-23 13:14:28 -04002572 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302573 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002574 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302575 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002576 return;
2577 }
2578
2579 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302580 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002581
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002582 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002583 if (ses->server->ops->tree_disconnect)
2584 ses->server->ops->tree_disconnect(xid, tcon);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002585 _free_xid(xid);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002586
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302587 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002588 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002589 cifs_put_smb_ses(ses);
2590}
2591
Steve French96daf2b2011-05-27 04:34:02 +00002592static struct cifs_tcon *
2593cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002594{
2595 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002596 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002597
2598 tcon = cifs_find_tcon(ses, volume_info->UNC);
2599 if (tcon) {
2600 cFYI(1, "Found match on UNC path");
2601 /* existing tcon already has a reference */
2602 cifs_put_smb_ses(ses);
2603 if (tcon->seal != volume_info->seal)
2604 cERROR(1, "transport encryption setting "
2605 "conflicts with existing tid");
2606 return tcon;
2607 }
2608
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002609 if (!ses->server->ops->tree_connect) {
2610 rc = -ENOSYS;
2611 goto out_fail;
2612 }
2613
Jeff Laytond00c28d2010-04-24 07:57:44 -04002614 tcon = tconInfoAlloc();
2615 if (tcon == NULL) {
2616 rc = -ENOMEM;
2617 goto out_fail;
2618 }
2619
2620 tcon->ses = ses;
2621 if (volume_info->password) {
2622 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2623 if (!tcon->password) {
2624 rc = -ENOMEM;
2625 goto out_fail;
2626 }
2627 }
2628
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002629 /*
2630 * BB Do we need to wrap session_mutex around this TCon call and Unix
2631 * SetFS as we do on SessSetup and reconnect?
2632 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002633 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002634 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2635 volume_info->local_nls);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002636 free_xid(xid);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002637 cFYI(1, "Tcon rc = %d", rc);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002638 if (rc)
2639 goto out_fail;
2640
2641 if (volume_info->nodfs) {
2642 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2643 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2644 }
2645 tcon->seal = volume_info->seal;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002646 /*
2647 * We can have only one retry value for a connection to a share so for
2648 * resources mounted more than once to the same server share the last
2649 * value passed in for the retry flag is used.
2650 */
Jeff Laytond00c28d2010-04-24 07:57:44 -04002651 tcon->retry = volume_info->retry;
2652 tcon->nocase = volume_info->nocase;
2653 tcon->local_lease = volume_info->local_lease;
Pavel Shilovsky233839b2012-09-19 06:22:45 -07002654 INIT_LIST_HEAD(&tcon->pending_opens);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002655
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302656 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002657 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302658 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002659
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302660 cifs_fscache_get_super_cookie(tcon);
2661
Jeff Laytond00c28d2010-04-24 07:57:44 -04002662 return tcon;
2663
2664out_fail:
2665 tconInfoFree(tcon);
2666 return ERR_PTR(rc);
2667}
2668
Jeff Layton9d002df2010-10-06 19:51:11 -04002669void
2670cifs_put_tlink(struct tcon_link *tlink)
2671{
2672 if (!tlink || IS_ERR(tlink))
2673 return;
2674
2675 if (!atomic_dec_and_test(&tlink->tl_count) ||
2676 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2677 tlink->tl_time = jiffies;
2678 return;
2679 }
2680
2681 if (!IS_ERR(tlink_tcon(tlink)))
2682 cifs_put_tcon(tlink_tcon(tlink));
2683 kfree(tlink);
2684 return;
2685}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002686
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002687static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002688cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2689{
2690 return cifs_sb->master_tlink;
2691}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002692
2693static int
2694compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2695{
2696 struct cifs_sb_info *old = CIFS_SB(sb);
2697 struct cifs_sb_info *new = mnt_data->cifs_sb;
2698
2699 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2700 return 0;
2701
2702 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2703 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2704 return 0;
2705
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002706 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002707 * We want to share sb only if we don't specify an r/wsize or
2708 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002709 */
2710 if (new->wsize && new->wsize < old->wsize)
2711 return 0;
2712
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002713 if (new->rsize && new->rsize < old->rsize)
2714 return 0;
2715
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002716 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2717 return 0;
2718
2719 if (old->mnt_file_mode != new->mnt_file_mode ||
2720 old->mnt_dir_mode != new->mnt_dir_mode)
2721 return 0;
2722
2723 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2724 return 0;
2725
2726 if (old->actimeo != new->actimeo)
2727 return 0;
2728
2729 return 1;
2730}
2731
2732int
2733cifs_match_super(struct super_block *sb, void *data)
2734{
2735 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2736 struct smb_vol *volume_info;
2737 struct cifs_sb_info *cifs_sb;
2738 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002739 struct cifs_ses *ses;
2740 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002741 struct tcon_link *tlink;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002742 int rc = 0;
2743
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002744 spin_lock(&cifs_tcp_ses_lock);
2745 cifs_sb = CIFS_SB(sb);
2746 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2747 if (IS_ERR(tlink)) {
2748 spin_unlock(&cifs_tcp_ses_lock);
2749 return rc;
2750 }
2751 tcon = tlink_tcon(tlink);
2752 ses = tcon->ses;
2753 tcp_srv = ses->server;
2754
2755 volume_info = mnt_data->vol;
2756
Jeff Layton9fa114f2012-11-26 11:09:57 -05002757 if (!match_server(tcp_srv, volume_info) ||
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002758 !match_session(ses, volume_info) ||
2759 !match_tcon(tcon, volume_info->UNC)) {
2760 rc = 0;
2761 goto out;
2762 }
2763
2764 rc = compare_mount_options(sb, mnt_data);
2765out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002766 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002767 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002768 return rc;
2769}
2770
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002772get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002773 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2774 struct dfs_info3_param **referrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775{
2776 char *temp_unc;
2777 int rc = 0;
2778
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002779 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002780 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002782 *num_referrals = 0;
2783 *referrals = NULL;
2784
2785 if (ses->ipc_tid == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 temp_unc = kmalloc(2 /* for slashes */ +
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002787 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2788 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 if (temp_unc == NULL)
2790 return -ENOMEM;
2791 temp_unc[0] = '\\';
2792 temp_unc[1] = '\\';
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002793 strcpy(temp_unc + 2, ses->serverName);
2794 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2795 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2796 nls_codepage);
2797 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 kfree(temp_unc);
2799 }
2800 if (rc == 0)
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002801 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2802 referrals, num_referrals,
2803 nls_codepage, remap);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002804 /*
2805 * BB - map targetUNCs to dfs_info3 structures, here or in
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002806 * ses->server->ops->get_dfs_refer.
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002807 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808
2809 return rc;
2810}
2811
Jeff Layton09e50d52008-07-23 10:11:19 -04002812#ifdef CONFIG_DEBUG_LOCK_ALLOC
2813static struct lock_class_key cifs_key[2];
2814static struct lock_class_key cifs_slock_key[2];
2815
2816static inline void
2817cifs_reclassify_socket4(struct socket *sock)
2818{
2819 struct sock *sk = sock->sk;
2820 BUG_ON(sock_owned_by_user(sk));
2821 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2822 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2823}
2824
2825static inline void
2826cifs_reclassify_socket6(struct socket *sock)
2827{
2828 struct sock *sk = sock->sk;
2829 BUG_ON(sock_owned_by_user(sk));
2830 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2831 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2832}
2833#else
2834static inline void
2835cifs_reclassify_socket4(struct socket *sock)
2836{
2837}
2838
2839static inline void
2840cifs_reclassify_socket6(struct socket *sock)
2841{
2842}
2843#endif
2844
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002846static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847{
Steve French50c2f752007-07-13 00:33:32 +00002848 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849
Steve French50c2f752007-07-13 00:33:32 +00002850 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 /* mask a nibble at a time and encode */
2852 target[j] = 'A' + (0x0F & (source[i] >> 4));
2853 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002854 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 }
2856
2857}
2858
Ben Greear3eb9a882010-09-01 17:06:02 -07002859static int
2860bind_socket(struct TCP_Server_Info *server)
2861{
2862 int rc = 0;
2863 if (server->srcaddr.ss_family != AF_UNSPEC) {
2864 /* Bind to the specified local IP address */
2865 struct socket *socket = server->ssocket;
2866 rc = socket->ops->bind(socket,
2867 (struct sockaddr *) &server->srcaddr,
2868 sizeof(server->srcaddr));
2869 if (rc < 0) {
2870 struct sockaddr_in *saddr4;
2871 struct sockaddr_in6 *saddr6;
2872 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2873 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2874 if (saddr6->sin6_family == AF_INET6)
2875 cERROR(1, "cifs: "
Jeff Laytonac3aa2f2012-07-23 13:14:28 -04002876 "Failed to bind to: %pI6c, error: %d",
Ben Greear3eb9a882010-09-01 17:06:02 -07002877 &saddr6->sin6_addr, rc);
2878 else
2879 cERROR(1, "cifs: "
Jeff Laytonac3aa2f2012-07-23 13:14:28 -04002880 "Failed to bind to: %pI4, error: %d",
Ben Greear3eb9a882010-09-01 17:06:02 -07002881 &saddr4->sin_addr.s_addr, rc);
2882 }
2883 }
2884 return rc;
2885}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886
2887static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002888ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889{
2890 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002891 /*
2892 * some servers require RFC1001 sessinit before sending
2893 * negprot - BB check reconnection in case where second
2894 * sessinit is sent but no second negprot
2895 */
2896 struct rfc1002_session_packet *ses_init_buf;
2897 struct smb_hdr *smb_buf;
2898 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2899 GFP_KERNEL);
2900 if (ses_init_buf) {
2901 ses_init_buf->trailer.session_req.called_len = 32;
2902
2903 if (server->server_RFC1001_name &&
2904 server->server_RFC1001_name[0] != 0)
2905 rfc1002mangle(ses_init_buf->trailer.
2906 session_req.called_name,
2907 server->server_RFC1001_name,
2908 RFC1001_NAME_LEN_WITH_NULL);
2909 else
2910 rfc1002mangle(ses_init_buf->trailer.
2911 session_req.called_name,
2912 DEFAULT_CIFS_CALLED_NAME,
2913 RFC1001_NAME_LEN_WITH_NULL);
2914
2915 ses_init_buf->trailer.session_req.calling_len = 32;
2916
2917 /*
2918 * calling name ends in null (byte 16) from old smb
2919 * convention.
2920 */
2921 if (server->workstation_RFC1001_name &&
2922 server->workstation_RFC1001_name[0] != 0)
2923 rfc1002mangle(ses_init_buf->trailer.
2924 session_req.calling_name,
2925 server->workstation_RFC1001_name,
2926 RFC1001_NAME_LEN_WITH_NULL);
2927 else
2928 rfc1002mangle(ses_init_buf->trailer.
2929 session_req.calling_name,
2930 "LINUX_CIFS_CLNT",
2931 RFC1001_NAME_LEN_WITH_NULL);
2932
2933 ses_init_buf->trailer.session_req.scope1 = 0;
2934 ses_init_buf->trailer.session_req.scope2 = 0;
2935 smb_buf = (struct smb_hdr *)ses_init_buf;
2936
2937 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002938 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002939 rc = smb_send(server, smb_buf, 0x44);
2940 kfree(ses_init_buf);
2941 /*
2942 * RFC1001 layer in at least one server
2943 * requires very short break before negprot
2944 * presumably because not expecting negprot
2945 * to follow so fast. This is a simple
2946 * solution that works without
2947 * complicating the code and causes no
2948 * significant slowing down on mount
2949 * for everyone else
2950 */
2951 usleep_range(1000, 2000);
2952 }
2953 /*
2954 * else the negprot may still work without this
2955 * even though malloc failed
2956 */
2957
2958 return rc;
2959}
2960
2961static int
2962generic_ip_connect(struct TCP_Server_Info *server)
2963{
2964 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00002965 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002966 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002967 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002968 struct sockaddr *saddr;
2969
2970 saddr = (struct sockaddr *) &server->dstaddr;
2971
2972 if (server->dstaddr.ss_family == AF_INET6) {
2973 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2974 slen = sizeof(struct sockaddr_in6);
2975 sfamily = AF_INET6;
2976 } else {
2977 sport = ((struct sockaddr_in *) saddr)->sin_port;
2978 slen = sizeof(struct sockaddr_in);
2979 sfamily = AF_INET;
2980 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002982 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06002983 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2984 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002986 cERROR(1, "Error %d creating socket", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002987 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002990
2991 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002992 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002993 server->ssocket = socket;
2994 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002995 if (sfamily == AF_INET6)
2996 cifs_reclassify_socket6(socket);
2997 else
2998 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999 }
3000
Ben Greear3eb9a882010-09-01 17:06:02 -07003001 rc = bind_socket(server);
3002 if (rc < 0)
3003 return rc;
3004
Jeff Laytond5c56052008-12-01 18:42:33 -05003005 /*
3006 * Eventually check for other socket options to change from
3007 * the default. sock_setsockopt not used because it expects
3008 * user space buffer
3009 */
3010 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00003011 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00003012
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003013 /* make the bufsizes depend on wsize/rsize and max requests */
3014 if (server->noautotune) {
3015 if (socket->sk->sk_sndbuf < (200 * 1024))
3016 socket->sk->sk_sndbuf = 200 * 1024;
3017 if (socket->sk->sk_rcvbuf < (140 * 1024))
3018 socket->sk->sk_rcvbuf = 140 * 1024;
3019 }
3020
Steve French6a5fa2362010-01-01 01:28:43 +00003021 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003022 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00003023 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3024 (char *)&val, sizeof(val));
3025 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003026 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00003027 }
3028
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003029 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3030 socket->sk->sk_sndbuf,
3031 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3032
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003033 rc = socket->ops->connect(socket, saddr, slen, 0);
3034 if (rc < 0) {
3035 cFYI(1, "Error %d connecting to server", rc);
3036 sock_release(socket);
3037 server->ssocket = NULL;
3038 return rc;
3039 }
3040
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003041 if (sport == htons(RFC1001_PORT))
3042 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003043
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 return rc;
3045}
3046
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003047static int
3048ip_connect(struct TCP_Server_Info *server)
3049{
Steve French6da97912011-03-13 18:55:55 +00003050 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003051 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3052 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3053
3054 if (server->dstaddr.ss_family == AF_INET6)
3055 sport = &addr6->sin6_port;
3056 else
3057 sport = &addr->sin_port;
3058
3059 if (*sport == 0) {
3060 int rc;
3061
3062 /* try with 445 port at first */
3063 *sport = htons(CIFS_PORT);
3064
3065 rc = generic_ip_connect(server);
3066 if (rc >= 0)
3067 return rc;
3068
3069 /* if it failed, try with 139 port */
3070 *sport = htons(RFC1001_PORT);
3071 }
3072
3073 return generic_ip_connect(server);
3074}
3075
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003076void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003077 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003078{
3079 /* if we are reconnecting then should we check to see if
3080 * any requested capabilities changed locally e.g. via
3081 * remount but we can not do much about it here
3082 * if they have (even if we could detect it by the following)
3083 * Perhaps we could add a backpointer to array of sb from tcon
3084 * or if we change to make all sb to same share the same
3085 * sb as NFS - then we only have one backpointer to sb.
3086 * What if we wanted to mount the server share twice once with
3087 * and once without posixacls or posix paths? */
3088 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003089
Steve Frenchc18c8422007-07-18 23:21:09 +00003090 if (vol_info && vol_info->no_linux_ext) {
3091 tcon->fsUnixInfo.Capability = 0;
3092 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003093 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00003094 return;
3095 } else if (vol_info)
3096 tcon->unix_ext = 1; /* Unix Extensions supported */
3097
3098 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003099 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00003100 return;
3101 }
Steve French50c2f752007-07-13 00:33:32 +00003102
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003103 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003104 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French6848b732011-05-26 18:38:54 +00003105 cFYI(1, "unix caps which server supports %lld", cap);
Steve French8af18972007-02-14 04:42:51 +00003106 /* check for reconnect case in which we do not
3107 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003108 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003109 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003110 originally at mount time */
3111 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3112 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003113 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3114 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003115 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00003116 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003117 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003118 cERROR(1, "possible reconnect error");
3119 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003120 }
Steve French8af18972007-02-14 04:42:51 +00003121 }
Steve French50c2f752007-07-13 00:33:32 +00003122
Steve French6848b732011-05-26 18:38:54 +00003123 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3124 cERROR(1, "per-share encryption not supported yet");
3125
Steve French8af18972007-02-14 04:42:51 +00003126 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00003127 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003128 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003129 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003130 cFYI(1, "negotiated posix acl support");
Al Viro2c6292a2011-06-17 09:05:48 -04003131 if (cifs_sb)
3132 cifs_sb->mnt_cifs_flags |=
3133 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003134 }
3135
Steve French75865f8c2007-06-24 18:30:48 +00003136 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003137 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003138 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003139 cFYI(1, "negotiate posix pathnames");
Al Viro2c6292a2011-06-17 09:05:48 -04003140 if (cifs_sb)
3141 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003142 CIFS_MOUNT_POSIX_PATHS;
3143 }
Steve French50c2f752007-07-13 00:33:32 +00003144
Joe Perchesb6b38f72010-04-21 03:50:45 +00003145 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003146#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00003147 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003148 cFYI(1, "FCNTL cap");
Steve French75865f8c2007-06-24 18:30:48 +00003149 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003150 cFYI(1, "EXTATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00003151 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003152 cFYI(1, "POSIX path cap");
Steve French75865f8c2007-06-24 18:30:48 +00003153 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003154 cFYI(1, "XATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00003155 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003156 cFYI(1, "POSIX ACL cap");
Steve French75865f8c2007-06-24 18:30:48 +00003157 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003158 cFYI(1, "very large read cap");
Steve French75865f8c2007-06-24 18:30:48 +00003159 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003160 cFYI(1, "very large write cap");
Steve French6848b732011-05-26 18:38:54 +00003161 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3162 cFYI(1, "transport encryption cap");
3163 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3164 cFYI(1, "mandatory transport encryption cap");
Steve French8af18972007-02-14 04:42:51 +00003165#endif /* CIFS_DEBUG2 */
3166 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003167 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003168 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00003169 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00003170 cERROR(1, "Negotiating Unix capabilities "
Jeff Laytonac3aa2f2012-07-23 13:14:28 -04003171 "with the server failed. Consider "
3172 "mounting with the Unix Extensions "
3173 "disabled if problems are found "
Steve French5a44b312007-09-20 15:16:24 +00003174 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00003175 "option.");
Steve French5a44b312007-09-20 15:16:24 +00003176
Steve French8af18972007-02-14 04:42:51 +00003177 }
3178 }
3179}
3180
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003181void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3182 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003183{
Jeff Layton2de970f2010-10-06 19:51:12 -04003184 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3185
Al Viro2ced6f62011-06-17 09:20:04 -04003186 spin_lock_init(&cifs_sb->tlink_tree_lock);
3187 cifs_sb->tlink_tree = RB_ROOT;
3188
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003189 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003190 * Temporarily set r/wsize for matching superblock. If we end up using
3191 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003192 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003193 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003194 cifs_sb->wsize = pvolume_info->wsize;
3195
Steve French3b795212008-11-13 19:45:32 +00003196 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3197 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3198 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3199 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Al Viro5206efd2011-07-26 03:22:14 -04003200 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003201 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003202
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303203 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003204 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303205
Steve French3b795212008-11-13 19:45:32 +00003206 if (pvolume_info->noperm)
3207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3208 if (pvolume_info->setuids)
3209 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3210 if (pvolume_info->server_ino)
3211 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3212 if (pvolume_info->remap)
3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3214 if (pvolume_info->no_xattr)
3215 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3216 if (pvolume_info->sfu_emul)
3217 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3218 if (pvolume_info->nobrl)
3219 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003220 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003221 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003222 if (pvolume_info->mand_lock)
3223 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003224 if (pvolume_info->rwpidforward)
3225 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003226 if (pvolume_info->cifs_acl)
3227 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003228 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003229 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003230 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3231 }
3232 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003233 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003234 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3235 }
Steve French3b795212008-11-13 19:45:32 +00003236 if (pvolume_info->override_uid)
3237 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3238 if (pvolume_info->override_gid)
3239 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3240 if (pvolume_info->dynperm)
3241 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303242 if (pvolume_info->fsc)
3243 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003244 if (pvolume_info->multiuser)
3245 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3246 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003247 if (pvolume_info->strict_io)
3248 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003249 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003250 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00003251 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3252 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003253 if (pvolume_info->mfsymlinks) {
3254 if (pvolume_info->sfu_emul) {
3255 cERROR(1, "mount option mfsymlinks ignored if sfu "
3256 "mount option is used");
3257 } else {
3258 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3259 }
3260 }
Steve French3b795212008-11-13 19:45:32 +00003261
3262 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00003263 cERROR(1, "mount option dynperm ignored if cifsacl "
3264 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003265}
3266
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003267static void
3268cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003269{
Sean Finneyb9468452011-04-11 13:19:32 +00003270 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003271 kzfree(volume_info->password);
Jesper Juhl95c75452011-08-27 18:58:34 +02003272 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003273 kfree(volume_info->domainname);
3274 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003275 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003276}
3277
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003278void
3279cifs_cleanup_volume_info(struct smb_vol *volume_info)
3280{
3281 if (!volume_info)
3282 return;
3283 cleanup_volume_info_contents(volume_info);
3284 kfree(volume_info);
3285}
3286
3287
Steve French2d6d5892009-04-09 00:36:44 +00003288#ifdef CONFIG_CIFS_DFS_UPCALL
Steve French6d3ea7e2012-11-28 22:34:41 -06003289/*
3290 * cifs_build_path_to_root returns full path to root when we do not have an
3291 * exiting connection (tcon)
3292 */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003293static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003294build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003295 const struct cifs_sb_info *cifs_sb)
3296{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003297 char *full_path, *pos;
Jeff Layton839db3d2012-12-10 06:10:45 -05003298 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003299 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003300
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003301 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003302 if (full_path == NULL)
3303 return ERR_PTR(-ENOMEM);
3304
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003305 strncpy(full_path, vol->UNC, unc_len);
3306 pos = full_path + unc_len;
3307
3308 if (pplen) {
Jeff Layton839db3d2012-12-10 06:10:45 -05003309 *pos++ = CIFS_DIR_SEP(cifs_sb);
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003310 strncpy(pos, vol->prepath, pplen);
3311 pos += pplen;
3312 }
3313
3314 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003315 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003316 cFYI(1, "%s: full_path=%s", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003317 return full_path;
3318}
Sean Finneydd613942011-04-11 13:19:30 +00003319
3320/*
3321 * Perform a dfs referral query for a share and (optionally) prefix
3322 *
Sean Finney046462a2011-04-11 13:19:33 +00003323 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3324 * to a string containing updated options for the submount. Otherwise it
3325 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003326 *
3327 * Returns the rc from get_dfs_path to the caller, which can be used to
3328 * determine whether there were referrals.
3329 */
3330static int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003331expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
Sean Finneydd613942011-04-11 13:19:30 +00003332 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003333 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003334{
3335 int rc;
3336 unsigned int num_referrals = 0;
3337 struct dfs_info3_param *referrals = NULL;
3338 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3339
3340 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3341 if (IS_ERR(full_path))
3342 return PTR_ERR(full_path);
3343
3344 /* For DFS paths, skip the first '\' of the UNC */
3345 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3346
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003347 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
Sean Finneydd613942011-04-11 13:19:30 +00003348 &num_referrals, &referrals,
3349 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3350
3351 if (!rc && num_referrals > 0) {
3352 char *fake_devname = NULL;
3353
3354 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3355 full_path + 1, referrals,
3356 &fake_devname);
3357
3358 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003359
Sean Finneydd613942011-04-11 13:19:30 +00003360 if (IS_ERR(mdata)) {
3361 rc = PTR_ERR(mdata);
3362 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003363 } else {
3364 cleanup_volume_info_contents(volume_info);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003365 rc = cifs_setup_volume_info(volume_info, mdata,
3366 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003367 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003368 kfree(fake_devname);
3369 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003370 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003371 }
3372 kfree(full_path);
3373 return rc;
3374}
Steve French2d6d5892009-04-09 00:36:44 +00003375#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003376
Jeff Layton04db79b2011-07-06 08:10:38 -04003377static int
3378cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3379 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003381 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003382
Jeff Layton04db79b2011-07-06 08:10:38 -04003383 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3384 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385
Jeff Layton7586b762008-12-01 18:41:49 -05003386 if (volume_info->nullauth) {
Jeff Layton04febab2012-01-17 16:09:15 -05003387 cFYI(1, "Anonymous login");
3388 kfree(volume_info->username);
3389 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003390 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003392 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08003394 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00003395 /* In userspace mount helper we can get user name from alternate
3396 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003397 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 }
3399
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003401 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003402 /* load_nls_default cannot return null */
3403 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003405 volume_info->local_nls = load_nls(volume_info->iocharset);
3406 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003407 cERROR(1, "CIFS mount error: iocharset %s not found",
3408 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003409 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410 }
3411 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003412
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003413 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003414}
3415
3416struct smb_vol *
3417cifs_get_volume_info(char *mount_data, const char *devname)
3418{
3419 int rc;
3420 struct smb_vol *volume_info;
3421
Jeff Layton6ee95422012-11-26 11:09:57 -05003422 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003423 if (!volume_info)
3424 return ERR_PTR(-ENOMEM);
3425
3426 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3427 if (rc) {
3428 cifs_cleanup_volume_info(volume_info);
3429 volume_info = ERR_PTR(rc);
3430 }
3431
3432 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003433}
3434
3435int
Al Viro2c6292a2011-06-17 09:05:48 -04003436cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003437{
Jeff Layton1daaae82012-03-21 06:30:40 -04003438 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003439 unsigned int xid;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003440 struct cifs_ses *ses;
Steve French96daf2b2011-05-27 04:34:02 +00003441 struct cifs_tcon *tcon;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003442 struct TCP_Server_Info *server;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003443 char *full_path;
3444 struct tcon_link *tlink;
3445#ifdef CONFIG_CIFS_DFS_UPCALL
3446 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003447#endif
Al Virodd854462011-06-17 08:24:42 -04003448
3449 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3450 if (rc)
3451 return rc;
3452
Jeff Layton20547492011-07-09 12:21:07 -04003453#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003454try_mount_again:
3455 /* cleanup activities if we're chasing a referral */
3456 if (referral_walks_count) {
3457 if (tcon)
3458 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003459 else if (ses)
3460 cifs_put_smb_ses(ses);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003461
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003462 free_xid(xid);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003463 }
3464#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003465 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003466 tcon = NULL;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003467 ses = NULL;
3468 server = NULL;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003469 full_path = NULL;
3470 tlink = NULL;
3471
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003472 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473
Jeff Layton63c038c2008-12-01 18:41:46 -05003474 /* get a reference to a tcp session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003475 server = cifs_get_tcp_session(volume_info);
3476 if (IS_ERR(server)) {
3477 rc = PTR_ERR(server);
Al Virodd854462011-06-17 08:24:42 -04003478 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003479 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 }
3481
Jeff Layton36988c72010-04-24 07:57:43 -04003482 /* get a reference to a SMB session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003483 ses = cifs_get_smb_ses(server, volume_info);
3484 if (IS_ERR(ses)) {
3485 rc = PTR_ERR(ses);
3486 ses = NULL;
Jeff Layton36988c72010-04-24 07:57:43 -04003487 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 }
Steve French50c2f752007-07-13 00:33:32 +00003489
Jeff Laytond00c28d2010-04-24 07:57:44 -04003490 /* search for existing tcon to this server share */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003491 tcon = cifs_get_tcon(ses, volume_info);
Jeff Laytond00c28d2010-04-24 07:57:44 -04003492 if (IS_ERR(tcon)) {
3493 rc = PTR_ERR(tcon);
3494 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003495 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003496 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003497
Steve French6848b732011-05-26 18:38:54 +00003498 /* tell server which Unix caps we support */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003499 if (cap_unix(tcon->ses)) {
Steve French6848b732011-05-26 18:38:54 +00003500 /* reset of caps checks mount to see if unix extensions
3501 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003502 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003503 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3504 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3505 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3506 rc = -EACCES;
3507 goto mount_fail_check;
3508 }
3509 } else
3510 tcon->unix_ext = 0; /* server does not support them */
3511
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003512 /* do not care if a following call succeed - informational */
3513 if (!tcon->ipc && server->ops->qfs_tcon)
3514 server->ops->qfs_tcon(xid, tcon);
Steve Frenchd82c2df2008-11-15 00:07:26 +00003515
Pavel Shilovsky24985c52012-09-18 16:20:28 -07003516 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3517 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003518
Jeff Layton66bfaad2011-10-19 15:30:35 -04003519 /* tune readahead according to rsize */
Jeff Layton8f714652012-05-01 17:41:49 -04003520 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003521
Igor Mammedove4cce942009-02-10 14:10:26 +03003522remote_path_check:
3523#ifdef CONFIG_CIFS_DFS_UPCALL
3524 /*
3525 * Perform an unconditional check for whether there are DFS
3526 * referrals for this path without prefix, to provide support
3527 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003528 * with PATH_NOT_COVERED to requests that include the prefix.
3529 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003530 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003531 if (referral_walks_count == 0) {
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003532 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3533 false);
Steve Frencheeac8042006-01-13 21:34:58 -08003534 if (!refrc) {
Steve French4523cc32007-04-30 20:13:06 +00003535 referral_walks_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536 goto try_mount_again;
3537 }
3538 }
3539#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003540
Steve Frenchf87d39d2011-05-27 03:50:55 +00003541 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003542 if (!rc && tcon) {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003543 if (!server->ops->is_path_accessible) {
3544 rc = -ENOSYS;
3545 goto mount_fail_check;
3546 }
Steve French6d3ea7e2012-11-28 22:34:41 -06003547 /*
3548 * cifs_build_path_to_root works only when we have a valid tcon
3549 */
3550 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551 if (full_path == NULL) {
3552 rc = -ENOMEM;
3553 goto mount_fail_check;
3554 }
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003555 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3556 full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003557 if (rc != 0 && rc != -EREMOTE) {
3558 kfree(full_path);
3559 goto mount_fail_check;
3560 }
3561 kfree(full_path);
3562 }
3563
3564 /* get referral if needed */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003565 if (rc == -EREMOTE) {
3566#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003567 if (referral_walks_count > MAX_NESTED_LINKS) {
3568 /*
3569 * BB: when we implement proper loop detection,
3570 * we will remove this check. But now we need it
3571 * to prevent an indefinite loop if 'DFS tree' is
3572 * misconfigured (i.e. has loops).
3573 */
3574 rc = -ELOOP;
3575 goto mount_fail_check;
3576 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003577
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003578 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003579
Sean Finneydd613942011-04-11 13:19:30 +00003580 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003581 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003582 goto try_mount_again;
3583 }
Sean Finneydd613942011-04-11 13:19:30 +00003584 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003585#else /* No DFS support, return error on mount */
3586 rc = -EOPNOTSUPP;
3587#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003588 }
3589
Jeff Layton9d002df2010-10-06 19:51:11 -04003590 if (rc)
3591 goto mount_fail_check;
3592
3593 /* now, hang the tcon off of the superblock */
3594 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3595 if (tlink == NULL) {
3596 rc = -ENOMEM;
3597 goto mount_fail_check;
3598 }
3599
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003600 tlink->tl_uid = ses->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003601 tlink->tl_tcon = tcon;
3602 tlink->tl_time = jiffies;
3603 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3604 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3605
Jeff Layton413e6612010-10-28 13:33:38 -04003606 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003607 spin_lock(&cifs_sb->tlink_tree_lock);
3608 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3609 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003610
Jeff Laytonda472fc2012-03-23 14:40:53 -04003611 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003612 TLINK_IDLE_EXPIRE);
3613
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003614mount_fail_check:
3615 /* on error free sesinfo and tcon struct if needed */
3616 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003617 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003618 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003619 if (tcon)
3620 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003621 else if (ses)
3622 cifs_put_smb_ses(ses);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003623 else
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003624 cifs_put_tcp_session(server);
Al Virodd854462011-06-17 08:24:42 -04003625 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003626 }
3627
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003629 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630 return rc;
3631}
3632
Jeff Layton8d1bca32011-06-11 21:17:10 -04003633/*
3634 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3635 * pointer may be NULL.
3636 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04003638CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
Steve French96daf2b2011-05-27 04:34:02 +00003639 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640 const struct nls_table *nls_codepage)
3641{
3642 struct smb_hdr *smb_buffer;
3643 struct smb_hdr *smb_buffer_response;
3644 TCONX_REQ *pSMB;
3645 TCONX_RSP *pSMBr;
3646 unsigned char *bcc_ptr;
3647 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003648 int length;
3649 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650
3651 if (ses == NULL)
3652 return -EIO;
3653
3654 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003655 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003657
Linus Torvalds1da177e2005-04-16 15:20:36 -07003658 smb_buffer_response = smb_buffer;
3659
3660 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3661 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003662
Pavel Shilovsky88257362012-05-23 14:01:59 +04003663 smb_buffer->Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664 smb_buffer->Uid = ses->Suid;
3665 pSMB = (TCONX_REQ *) smb_buffer;
3666 pSMBr = (TCONX_RSP *) smb_buffer_response;
3667
3668 pSMB->AndXCommand = 0xFF;
3669 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003670 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003671 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003672 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003673 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003674 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003675 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003676 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003677 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003678 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3679 specified as required (when that support is added to
3680 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003681 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003682 by Samba (not sure whether other servers allow
3683 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003684#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003685 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003686 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003687 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003688 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003689 SECMODE_PW_ENCRYPT ? true : false,
3690 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003691 else
3692#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003693 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003694 bcc_ptr, nls_codepage);
Steve Frencheeac8042006-01-13 21:34:58 -08003695
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003696 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003697 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003698 /* must align unicode strings */
3699 *bcc_ptr = 0; /* null byte password */
3700 bcc_ptr++;
3701 }
Steve Frencheeac8042006-01-13 21:34:58 -08003702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703
Steve French96daf2b2011-05-27 04:34:02 +00003704 if (ses->server->sec_mode &
Steve Frencha878fb22006-05-30 18:04:19 +00003705 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003706 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3707
3708 if (ses->capabilities & CAP_STATUS32) {
3709 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3710 }
3711 if (ses->capabilities & CAP_DFS) {
3712 smb_buffer->Flags2 |= SMBFLG2_DFS;
3713 }
3714 if (ses->capabilities & CAP_UNICODE) {
3715 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3716 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003717 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003718 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003719 (/* server len*/ + 256 /* share len */), nls_codepage);
3720 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003721 bcc_ptr += 2; /* skip trailing null */
3722 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003723 strcpy(bcc_ptr, tree);
3724 bcc_ptr += strlen(tree) + 1;
3725 }
3726 strcpy(bcc_ptr, "?????");
3727 bcc_ptr += strlen("?????");
3728 bcc_ptr += 1;
3729 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003730 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3731 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732 pSMB->ByteCount = cpu_to_le16(count);
3733
Steve French133672e2007-11-13 22:41:37 +00003734 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003735 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736
Linus Torvalds1da177e2005-04-16 15:20:36 -07003737 /* above now done in SendReceive */
3738 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003739 bool is_unicode;
3740
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003742 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743 tcon->tid = smb_buffer_response->Tid;
3744 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003745 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003746 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003747 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3748 is_unicode = true;
3749 else
3750 is_unicode = false;
3751
Jeff Laytoncc20c032009-04-30 07:16:21 -04003752
Steve French50c2f752007-07-13 00:33:32 +00003753 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003754 if (length == 3) {
3755 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3756 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003757 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003758 tcon->ipc = 1;
3759 }
3760 } else if (length == 2) {
3761 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3762 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003763 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003764 }
3765 }
Steve French50c2f752007-07-13 00:33:32 +00003766 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003767 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003768 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003769
3770 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003771 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003772 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003773 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003774 nls_codepage);
3775
Joe Perchesb6b38f72010-04-21 03:50:45 +00003776 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003777
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003778 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003779 (smb_buffer_response->WordCount == 7))
3780 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003781 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3782 else
3783 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003784 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003786 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003787 ses->ipc_tid = smb_buffer_response->Tid;
3788 }
3789
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003790 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003791 return rc;
3792}
3793
Al Viro2a9b9952011-06-17 09:27:16 -04003794void
3795cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003796{
Jeff Laytonb647c352010-10-28 11:16:44 -04003797 struct rb_root *root = &cifs_sb->tlink_tree;
3798 struct rb_node *node;
3799 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003800
Jeff Layton2de970f2010-10-06 19:51:12 -04003801 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3802
Jeff Laytonb647c352010-10-28 11:16:44 -04003803 spin_lock(&cifs_sb->tlink_tree_lock);
3804 while ((node = rb_first(root))) {
3805 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3806 cifs_get_tlink(tlink);
3807 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3808 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003809
Jeff Laytonb647c352010-10-28 11:16:44 -04003810 spin_unlock(&cifs_sb->tlink_tree_lock);
3811 cifs_put_tlink(tlink);
3812 spin_lock(&cifs_sb->tlink_tree_lock);
3813 }
3814 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003815
Al Virodd854462011-06-17 08:24:42 -04003816 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003817 kfree(cifs_sb->mountdata);
3818 unload_nls(cifs_sb->local_nls);
3819 kfree(cifs_sb);
Steve French50c2f752007-07-13 00:33:32 +00003820}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003821
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003822int
3823cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824{
3825 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003826 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003827
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003828 if (!server->ops->need_neg || !server->ops->negotiate)
3829 return -ENOSYS;
3830
Jeff Layton198b5682010-04-24 07:57:48 -04003831 /* only send once per connect */
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003832 if (!server->ops->need_neg(server))
Jeff Layton198b5682010-04-24 07:57:48 -04003833 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003834
Pavel Shilovsky45275782012-05-17 17:53:29 +04003835 set_credits(server, 1);
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003836
3837 rc = server->ops->negotiate(xid, ses);
Jeff Layton198b5682010-04-24 07:57:48 -04003838 if (rc == 0) {
3839 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003840 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003841 server->tcpStatus = CifsGood;
3842 else
3843 rc = -EHOSTDOWN;
3844 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003845 }
Steve French26b994f2008-08-06 05:11:33 +00003846
Jeff Layton198b5682010-04-24 07:57:48 -04003847 return rc;
3848}
Steve French26b994f2008-08-06 05:11:33 +00003849
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003850int
3851cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3852 struct nls_table *nls_info)
Jeff Layton198b5682010-04-24 07:57:48 -04003853{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003854 int rc = -ENOSYS;
Jeff Layton198b5682010-04-24 07:57:48 -04003855 struct TCP_Server_Info *server = ses->server;
3856
3857 ses->flags = 0;
3858 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003859 if (linuxExtEnabled == 0)
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003860 ses->capabilities &= (~server->vals->cap_unix);
Steve French20418ac2009-04-30 16:13:32 +00003861
Joe Perchesb6b38f72010-04-21 03:50:45 +00003862 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Steve French96daf2b2011-05-27 04:34:02 +00003863 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003864
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003865 if (server->ops->sess_setup)
3866 rc = server->ops->sess_setup(xid, ses, nls_info);
3867
Steve French26b994f2008-08-06 05:11:33 +00003868 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003869 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00003870 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003871 mutex_lock(&ses->server->srv_mutex);
3872 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003873 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003874 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003875 server->sequence_number = 0x2;
3876 server->session_estab = true;
3877 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003878 }
3879 mutex_unlock(&server->srv_mutex);
3880
Joe Perchesb6b38f72010-04-21 03:50:45 +00003881 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00003882 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003883 ses->status = CifsGood;
3884 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003885 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003886 }
3887
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003888 kfree(ses->auth_key.response);
3889 ses->auth_key.response = NULL;
3890 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003891 kfree(ses->ntlmssp);
3892 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003893
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 return rc;
3895}
3896
Jeff Layton8a8798a2012-01-17 16:09:15 -05003897static int
3898cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3899{
3900 switch (ses->server->secType) {
3901 case Kerberos:
3902 vol->secFlg = CIFSSEC_MUST_KRB5;
3903 return 0;
3904 case NTLMv2:
3905 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3906 break;
3907 case NTLM:
3908 vol->secFlg = CIFSSEC_MUST_NTLM;
3909 break;
3910 case RawNTLMSSP:
3911 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3912 break;
3913 case LANMAN:
3914 vol->secFlg = CIFSSEC_MUST_LANMAN;
3915 break;
3916 }
3917
3918 return cifs_set_cifscreds(vol, ses);
3919}
3920
Steve French96daf2b2011-05-27 04:34:02 +00003921static struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04003922cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3923{
Jeff Layton8a8798a2012-01-17 16:09:15 -05003924 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00003925 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3926 struct cifs_ses *ses;
3927 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04003928 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04003929
3930 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03003931 if (vol_info == NULL)
3932 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04003933
Jeff Layton9d002df2010-10-06 19:51:11 -04003934 vol_info->local_nls = cifs_sb->local_nls;
3935 vol_info->linux_uid = fsuid;
3936 vol_info->cred_uid = fsuid;
3937 vol_info->UNC = master_tcon->treeName;
3938 vol_info->retry = master_tcon->retry;
3939 vol_info->nocase = master_tcon->nocase;
3940 vol_info->local_lease = master_tcon->local_lease;
3941 vol_info->no_linux_ext = !master_tcon->unix_ext;
3942
Jeff Layton8a8798a2012-01-17 16:09:15 -05003943 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3944 if (rc) {
3945 tcon = ERR_PTR(rc);
3946 goto out;
3947 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003948
3949 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303950 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003951 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303952 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003953
3954 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3955 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00003956 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04003957 cifs_put_tcp_session(master_tcon->ses->server);
3958 goto out;
3959 }
3960
3961 tcon = cifs_get_tcon(ses, vol_info);
3962 if (IS_ERR(tcon)) {
3963 cifs_put_smb_ses(ses);
3964 goto out;
3965 }
3966
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003967 if (cap_unix(ses))
Jeff Layton9d002df2010-10-06 19:51:11 -04003968 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3969out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05003970 kfree(vol_info->username);
3971 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04003972 kfree(vol_info);
3973
3974 return tcon;
3975}
3976
Steve French96daf2b2011-05-27 04:34:02 +00003977struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04003978cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3979{
3980 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3981}
3982
3983static int
3984cifs_sb_tcon_pending_wait(void *unused)
3985{
3986 schedule();
3987 return signal_pending(current) ? -ERESTARTSYS : 0;
3988}
3989
Jeff Laytonb647c352010-10-28 11:16:44 -04003990/* find and return a tlink with given uid */
3991static struct tcon_link *
3992tlink_rb_search(struct rb_root *root, uid_t uid)
3993{
3994 struct rb_node *node = root->rb_node;
3995 struct tcon_link *tlink;
3996
3997 while (node) {
3998 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3999
4000 if (tlink->tl_uid > uid)
4001 node = node->rb_left;
4002 else if (tlink->tl_uid < uid)
4003 node = node->rb_right;
4004 else
4005 return tlink;
4006 }
4007 return NULL;
4008}
4009
4010/* insert a tcon_link into the tree */
4011static void
4012tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4013{
4014 struct rb_node **new = &(root->rb_node), *parent = NULL;
4015 struct tcon_link *tlink;
4016
4017 while (*new) {
4018 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4019 parent = *new;
4020
4021 if (tlink->tl_uid > new_tlink->tl_uid)
4022 new = &((*new)->rb_left);
4023 else
4024 new = &((*new)->rb_right);
4025 }
4026
4027 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4028 rb_insert_color(&new_tlink->tl_rbnode, root);
4029}
4030
Jeff Layton9d002df2010-10-06 19:51:11 -04004031/*
4032 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4033 * current task.
4034 *
4035 * If the superblock doesn't refer to a multiuser mount, then just return
4036 * the master tcon for the mount.
4037 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05304038 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04004039 * exists, then check to see if it's pending construction. If it is then wait
4040 * for construction to complete. Once it's no longer pending, check to see if
4041 * it failed and either return an error or retry construction, depending on
4042 * the timeout.
4043 *
4044 * If one doesn't exist then insert a new tcon_link struct into the tree and
4045 * try to construct a new one.
4046 */
4047struct tcon_link *
4048cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4049{
4050 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04004051 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004052 struct tcon_link *tlink, *newtlink;
4053
4054 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4055 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4056
4057 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004058 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004059 if (tlink)
4060 cifs_get_tlink(tlink);
4061 spin_unlock(&cifs_sb->tlink_tree_lock);
4062
4063 if (tlink == NULL) {
4064 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4065 if (newtlink == NULL)
4066 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004067 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004068 newtlink->tl_tcon = ERR_PTR(-EACCES);
4069 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4070 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4071 cifs_get_tlink(newtlink);
4072
Jeff Layton9d002df2010-10-06 19:51:11 -04004073 spin_lock(&cifs_sb->tlink_tree_lock);
4074 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004075 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004076 if (tlink) {
4077 cifs_get_tlink(tlink);
4078 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004079 kfree(newtlink);
4080 goto wait_for_construction;
4081 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004082 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004083 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4084 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004085 } else {
4086wait_for_construction:
4087 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4088 cifs_sb_tcon_pending_wait,
4089 TASK_INTERRUPTIBLE);
4090 if (ret) {
4091 cifs_put_tlink(tlink);
4092 return ERR_PTR(ret);
4093 }
4094
4095 /* if it's good, return it */
4096 if (!IS_ERR(tlink->tl_tcon))
4097 return tlink;
4098
4099 /* return error if we tried this already recently */
4100 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4101 cifs_put_tlink(tlink);
4102 return ERR_PTR(-EACCES);
4103 }
4104
4105 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4106 goto wait_for_construction;
4107 }
4108
4109 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4110 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4111 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4112
4113 if (IS_ERR(tlink->tl_tcon)) {
4114 cifs_put_tlink(tlink);
4115 return ERR_PTR(-EACCES);
4116 }
4117
4118 return tlink;
4119}
Jeff Layton2de970f2010-10-06 19:51:12 -04004120
4121/*
4122 * periodic workqueue job that scans tcon_tree for a superblock and closes
4123 * out tcons.
4124 */
4125static void
4126cifs_prune_tlinks(struct work_struct *work)
4127{
4128 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4129 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004130 struct rb_root *root = &cifs_sb->tlink_tree;
4131 struct rb_node *node = rb_first(root);
4132 struct rb_node *tmp;
4133 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004134
Jeff Laytonb647c352010-10-28 11:16:44 -04004135 /*
4136 * Because we drop the spinlock in the loop in order to put the tlink
4137 * it's not guarded against removal of links from the tree. The only
4138 * places that remove entries from the tree are this function and
4139 * umounts. Because this function is non-reentrant and is canceled
4140 * before umount can proceed, this is safe.
4141 */
4142 spin_lock(&cifs_sb->tlink_tree_lock);
4143 node = rb_first(root);
4144 while (node != NULL) {
4145 tmp = node;
4146 node = rb_next(tmp);
4147 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4148
4149 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4150 atomic_read(&tlink->tl_count) != 0 ||
4151 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4152 continue;
4153
4154 cifs_get_tlink(tlink);
4155 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4156 rb_erase(tmp, root);
4157
Jeff Layton2de970f2010-10-06 19:51:12 -04004158 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004159 cifs_put_tlink(tlink);
4160 spin_lock(&cifs_sb->tlink_tree_lock);
4161 }
4162 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004163
Jeff Laytonda472fc2012-03-23 14:40:53 -04004164 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004165 TLINK_IDLE_EXPIRE);
4166}