blob: e0b56d7a19c561be0b173a670d18f6d8435a12ed [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve Frenchd185cda2009-04-30 17:45:10 +00004 * Copyright (C) International Business Machines Corp., 2002,2009
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
Jeff Laytonc74093b2011-01-11 07:24:23 -050059/* SMB echo "timeout" -- FIXME: tunable? */
60#define SMB_ECHO_INTERVAL (60 * HZ)
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062extern mempool_t *cifs_req_poolp;
63
Jeff Layton2de970f2010-10-06 19:51:12 -040064/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -040065#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -040066#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -040067
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040068enum {
69
70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
73 Opt_noblocksend, Opt_noautotune,
74 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
75 Opt_mapchars, Opt_nomapchars, Opt_sfu,
76 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
77 Opt_noposixpaths, Opt_nounix,
78 Opt_nocase,
79 Opt_brl, Opt_nobrl,
80 Opt_forcemandatorylock, Opt_setuids,
81 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
82 Opt_nohard, Opt_nosoft,
83 Opt_nointr, Opt_intr,
84 Opt_nostrictsync, Opt_strictsync,
85 Opt_serverino, Opt_noserverino,
86 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
87 Opt_acl, Opt_noacl, Opt_locallease,
88 Opt_sign, Opt_seal, Opt_direct,
89 Opt_strictcache, Opt_noac,
90 Opt_fsc, Opt_mfsymlinks,
Jeff Laytond8162552012-03-23 14:40:56 -040091 Opt_multiuser, Opt_sloppy,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040092
93 /* Mount options which take numeric value */
94 Opt_backupuid, Opt_backupgid, Opt_uid,
95 Opt_cruid, Opt_gid, Opt_file_mode,
96 Opt_dirmode, Opt_port,
97 Opt_rsize, Opt_wsize, Opt_actimeo,
98
99 /* Mount options which take string value */
100 Opt_user, Opt_pass, Opt_ip,
101 Opt_unc, Opt_domain,
102 Opt_srcaddr, Opt_prefixpath,
103 Opt_iocharset, Opt_sockopt,
104 Opt_netbiosname, Opt_servern,
105 Opt_ver, Opt_sec,
106
107 /* Mount options to be ignored */
108 Opt_ignore,
109
110 /* Options which could be blank */
111 Opt_blank_pass,
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100112 Opt_blank_user,
113 Opt_blank_ip,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400114
115 Opt_err
116};
117
118static const match_table_t cifs_mount_option_tokens = {
119
120 { Opt_user_xattr, "user_xattr" },
121 { Opt_nouser_xattr, "nouser_xattr" },
122 { Opt_forceuid, "forceuid" },
123 { Opt_noforceuid, "noforceuid" },
124 { Opt_noblocksend, "noblocksend" },
125 { Opt_noautotune, "noautotune" },
126 { Opt_hard, "hard" },
127 { Opt_soft, "soft" },
128 { Opt_perm, "perm" },
129 { Opt_noperm, "noperm" },
130 { Opt_mapchars, "mapchars" },
131 { Opt_nomapchars, "nomapchars" },
132 { Opt_sfu, "sfu" },
133 { Opt_nosfu, "nosfu" },
134 { Opt_nodfs, "nodfs" },
135 { Opt_posixpaths, "posixpaths" },
136 { Opt_noposixpaths, "noposixpaths" },
137 { Opt_nounix, "nounix" },
138 { Opt_nounix, "nolinux" },
139 { Opt_nocase, "nocase" },
140 { Opt_nocase, "ignorecase" },
141 { Opt_brl, "brl" },
142 { Opt_nobrl, "nobrl" },
143 { Opt_nobrl, "nolock" },
144 { Opt_forcemandatorylock, "forcemandatorylock" },
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +0400145 { Opt_forcemandatorylock, "forcemand" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400146 { Opt_setuids, "setuids" },
147 { Opt_nosetuids, "nosetuids" },
148 { Opt_dynperm, "dynperm" },
149 { Opt_nodynperm, "nodynperm" },
150 { Opt_nohard, "nohard" },
151 { Opt_nosoft, "nosoft" },
152 { Opt_nointr, "nointr" },
153 { Opt_intr, "intr" },
154 { Opt_nostrictsync, "nostrictsync" },
155 { Opt_strictsync, "strictsync" },
156 { Opt_serverino, "serverino" },
157 { Opt_noserverino, "noserverino" },
158 { Opt_rwpidforward, "rwpidforward" },
159 { Opt_cifsacl, "cifsacl" },
160 { Opt_nocifsacl, "nocifsacl" },
161 { Opt_acl, "acl" },
162 { Opt_noacl, "noacl" },
163 { Opt_locallease, "locallease" },
164 { Opt_sign, "sign" },
165 { Opt_seal, "seal" },
166 { Opt_direct, "direct" },
Jeff Layton531c8ff2012-05-16 07:12:26 -0400167 { Opt_direct, "directio" },
168 { Opt_direct, "forcedirectio" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400169 { Opt_strictcache, "strictcache" },
170 { Opt_noac, "noac" },
171 { Opt_fsc, "fsc" },
172 { Opt_mfsymlinks, "mfsymlinks" },
173 { Opt_multiuser, "multiuser" },
Jeff Laytond8162552012-03-23 14:40:56 -0400174 { Opt_sloppy, "sloppy" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400175
176 { Opt_backupuid, "backupuid=%s" },
177 { Opt_backupgid, "backupgid=%s" },
178 { Opt_uid, "uid=%s" },
179 { Opt_cruid, "cruid=%s" },
180 { Opt_gid, "gid=%s" },
181 { Opt_file_mode, "file_mode=%s" },
182 { Opt_dirmode, "dirmode=%s" },
183 { Opt_dirmode, "dir_mode=%s" },
184 { Opt_port, "port=%s" },
185 { Opt_rsize, "rsize=%s" },
186 { Opt_wsize, "wsize=%s" },
187 { Opt_actimeo, "actimeo=%s" },
188
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100189 { Opt_blank_user, "user=" },
190 { Opt_blank_user, "username=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400191 { Opt_user, "user=%s" },
192 { Opt_user, "username=%s" },
193 { Opt_blank_pass, "pass=" },
194 { Opt_pass, "pass=%s" },
195 { Opt_pass, "password=%s" },
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100196 { Opt_blank_ip, "ip=" },
197 { Opt_blank_ip, "addr=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400198 { Opt_ip, "ip=%s" },
199 { Opt_ip, "addr=%s" },
200 { Opt_unc, "unc=%s" },
201 { Opt_unc, "target=%s" },
202 { Opt_unc, "path=%s" },
203 { Opt_domain, "dom=%s" },
204 { Opt_domain, "domain=%s" },
205 { Opt_domain, "workgroup=%s" },
206 { Opt_srcaddr, "srcaddr=%s" },
207 { Opt_prefixpath, "prefixpath=%s" },
208 { Opt_iocharset, "iocharset=%s" },
209 { Opt_sockopt, "sockopt=%s" },
210 { Opt_netbiosname, "netbiosname=%s" },
211 { Opt_servern, "servern=%s" },
212 { Opt_ver, "ver=%s" },
213 { Opt_ver, "vers=%s" },
214 { Opt_ver, "version=%s" },
215 { Opt_sec, "sec=%s" },
216
217 { Opt_ignore, "cred" },
218 { Opt_ignore, "credentials" },
Jeff Laytona557b972012-05-02 14:02:40 -0400219 { Opt_ignore, "cred=%s" },
220 { Opt_ignore, "credentials=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400221 { Opt_ignore, "guest" },
222 { Opt_ignore, "rw" },
223 { Opt_ignore, "ro" },
224 { Opt_ignore, "suid" },
225 { Opt_ignore, "nosuid" },
226 { Opt_ignore, "exec" },
227 { Opt_ignore, "noexec" },
228 { Opt_ignore, "nodev" },
229 { Opt_ignore, "noauto" },
230 { Opt_ignore, "dev" },
231 { Opt_ignore, "mand" },
232 { Opt_ignore, "nomand" },
233 { Opt_ignore, "_netdev" },
234
235 { Opt_err, NULL }
236};
237
238enum {
239 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
240 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
241 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2i,
242 Opt_sec_nontlm, Opt_sec_lanman,
243 Opt_sec_none,
244
245 Opt_sec_err
246};
247
248static const match_table_t cifs_secflavor_tokens = {
249 { Opt_sec_krb5, "krb5" },
250 { Opt_sec_krb5i, "krb5i" },
251 { Opt_sec_krb5p, "krb5p" },
252 { Opt_sec_ntlmsspi, "ntlmsspi" },
253 { Opt_sec_ntlmssp, "ntlmssp" },
254 { Opt_ntlm, "ntlm" },
255 { Opt_sec_ntlmi, "ntlmi" },
256 { Opt_sec_ntlmv2i, "ntlmv2i" },
257 { Opt_sec_nontlm, "nontlm" },
258 { Opt_sec_lanman, "lanman" },
259 { Opt_sec_none, "none" },
260
261 { Opt_sec_err, NULL }
262};
263
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300264static int ip_connect(struct TCP_Server_Info *server);
265static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400266static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400267static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -0400268static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
269 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Jeff Laytond5c56052008-12-01 18:42:33 -0500271/*
272 * cifs tcp session reconnection
273 *
274 * mark tcp session as reconnecting so temporarily locked
275 * mark all smb sessions as reconnecting for tcp session
276 * reconnect tcp session
277 * wake up waiters on reconnection? - (not needed currently)
278 */
Steve French2cd646a2006-09-28 19:43:08 +0000279static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280cifs_reconnect(struct TCP_Server_Info *server)
281{
282 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500283 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000284 struct cifs_ses *ses;
285 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000286 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400287 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +0000288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000290 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000291 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 next time through the loop */
293 spin_unlock(&GlobalMid_Lock);
294 return rc;
295 } else
296 server->tcpStatus = CifsNeedReconnect;
297 spin_unlock(&GlobalMid_Lock);
298 server->maxBuf = 0;
299
Joe Perchesb6b38f72010-04-21 03:50:45 +0000300 cFYI(1, "Reconnecting tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 /* before reconnecting the tcp session, mark the smb session (uid)
303 and the tid bad so they are not used until reconnected */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500304 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530305 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500306 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000307 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500308 ses->need_reconnect = true;
309 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500310 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000311 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500312 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530315 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 /* do not want to be sending data on a socket we are freeing */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500318 cFYI(1, "%s: tearing down socket", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500319 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000320 if (server->ssocket) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000321 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
322 server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800323 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000324 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000325 server->ssocket->state,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000326 server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 sock_release(server->ssocket);
328 server->ssocket = NULL;
329 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500330 server->sequence_number = 0;
331 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500332 kfree(server->session_key.response);
333 server->session_key.response = NULL;
334 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000335 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500336 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500338 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400339 INIT_LIST_HEAD(&retry_list);
340 cFYI(1, "%s: moving mids to private list", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500342 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
343 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400344 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
345 mid_entry->mid_state = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400346 list_move(&mid_entry->qhead, &retry_list);
347 }
348 spin_unlock(&GlobalMid_Lock);
349
350 cFYI(1, "%s: issuing mid callbacks", __func__);
351 list_for_each_safe(tmp, tmp2, &retry_list) {
352 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500353 list_del_init(&mid_entry->qhead);
354 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400357 do {
Steve French6c3d8902006-07-31 22:46:20 +0000358 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300359
360 /* we should try only the port we connected to before */
361 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000362 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000363 cFYI(1, "reconnect error %d", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700364 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 } else {
366 atomic_inc(&tcpSesReconnectCount);
367 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000368 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000369 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000370 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400372 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 return rc;
375}
376
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000377/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700378 return codes:
379 0 not a transact2, or all data present
380 >0 transact2 with that much data missing
381 -EINVAL = invalid transact2
382
383 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400384static int check2ndT2(char *buf)
Steve Frenche4eb2952005-04-28 22:41:09 -0700385{
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400386 struct smb_hdr *pSMB = (struct smb_hdr *)buf;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000387 struct smb_t2_rsp *pSMBt;
Steve Frenche4eb2952005-04-28 22:41:09 -0700388 int remaining;
Jeff Layton26ec2542011-01-20 13:36:51 -0500389 __u16 total_data_size, data_in_this_rsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700390
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000391 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700392 return 0;
393
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000394 /* check for plausible wct, bcc and t2 data and parm sizes */
395 /* check for parm and data offset going beyond end of smb */
396 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000397 cFYI(1, "invalid transact2 word count");
Steve Frenche4eb2952005-04-28 22:41:09 -0700398 return -EINVAL;
399 }
400
401 pSMBt = (struct smb_t2_rsp *)pSMB;
402
Jeff Layton26ec2542011-01-20 13:36:51 -0500403 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
404 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700405
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400406 if (total_data_size == data_in_this_rsp)
Steve Frenche4eb2952005-04-28 22:41:09 -0700407 return 0;
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400408 else if (total_data_size < data_in_this_rsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000409 cFYI(1, "total data %d smaller than data in frame %d",
410 total_data_size, data_in_this_rsp);
Steve Frenche4eb2952005-04-28 22:41:09 -0700411 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700412 }
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400413
414 remaining = total_data_size - data_in_this_rsp;
415
416 cFYI(1, "missing %d bytes from transact2, check next response",
417 remaining);
Jeff Laytonc974bef2011-10-11 06:41:32 -0400418 if (total_data_size > CIFSMaxBufSize) {
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400419 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
Jeff Laytonc974bef2011-10-11 06:41:32 -0400420 total_data_size, CIFSMaxBufSize);
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400421 return -EINVAL;
422 }
423 return remaining;
Steve Frenche4eb2952005-04-28 22:41:09 -0700424}
425
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400426static int coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
Steve Frenche4eb2952005-04-28 22:41:09 -0700427{
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400428 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
429 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr;
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500430 char *data_area_of_tgt;
431 char *data_area_of_src;
Jeff Layton26ec2542011-01-20 13:36:51 -0500432 int remaining;
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500433 unsigned int byte_count, total_in_tgt;
434 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
Steve Frenche4eb2952005-04-28 22:41:09 -0700435
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500436 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
437 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700438
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500439 if (tgt_total_cnt != src_total_cnt)
440 cFYI(1, "total data count of primary and secondary t2 differ "
441 "source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
Steve Frenche4eb2952005-04-28 22:41:09 -0700442
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500443 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700444
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500445 remaining = tgt_total_cnt - total_in_tgt;
Steve French50c2f752007-07-13 00:33:32 +0000446
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500447 if (remaining < 0) {
448 cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
449 "total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
Jeff Layton2a2047b2011-04-27 13:29:49 -0400450 return -EPROTO;
Steve Frenche4eb2952005-04-28 22:41:09 -0700451 }
452
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500453 if (remaining == 0) {
454 /* nothing to do, ignore */
455 cFYI(1, "no more data remains");
456 return 0;
457 }
458
459 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
460 if (remaining < total_in_src)
461 cFYI(1, "transact2 2nd response contains too much data");
462
Steve Frenche4eb2952005-04-28 22:41:09 -0700463 /* find end of first SMB data area */
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500464 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
Jeff Layton26ec2542011-01-20 13:36:51 -0500465 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500466
Steve Frenche4eb2952005-04-28 22:41:09 -0700467 /* validate target area */
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500468 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
469 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700470
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500471 data_area_of_tgt += total_in_tgt;
Steve Frenche4eb2952005-04-28 22:41:09 -0700472
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500473 total_in_tgt += total_in_src;
Jeff Layton2a2047b2011-04-27 13:29:49 -0400474 /* is the result too big for the field? */
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500475 if (total_in_tgt > USHRT_MAX) {
476 cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
Jeff Layton2a2047b2011-04-27 13:29:49 -0400477 return -EPROTO;
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500478 }
479 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
Jeff Layton2a2047b2011-04-27 13:29:49 -0400480
481 /* fix up the BCC */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400482 byte_count = get_bcc(target_hdr);
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500483 byte_count += total_in_src;
Jeff Layton2a2047b2011-04-27 13:29:49 -0400484 /* is the result too big for the field? */
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500485 if (byte_count > USHRT_MAX) {
486 cFYI(1, "coalesced BCC too large (%u)", byte_count);
Jeff Layton2a2047b2011-04-27 13:29:49 -0400487 return -EPROTO;
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500488 }
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400489 put_bcc(byte_count, target_hdr);
Steve Frenche4eb2952005-04-28 22:41:09 -0700490
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400491 byte_count = be32_to_cpu(target_hdr->smb_buf_length);
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500492 byte_count += total_in_src;
Jeff Layton2a2047b2011-04-27 13:29:49 -0400493 /* don't allow buffer to overflow */
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500494 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
495 cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
Jeff Layton2a2047b2011-04-27 13:29:49 -0400496 return -ENOBUFS;
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500497 }
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400498 target_hdr->smb_buf_length = cpu_to_be32(byte_count);
Steve Frenche4eb2952005-04-28 22:41:09 -0700499
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500500 /* copy second buffer into end of first buffer */
501 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
Jeff Layton2a2047b2011-04-27 13:29:49 -0400502
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500503 if (remaining != total_in_src) {
504 /* more responses to go */
505 cFYI(1, "waiting for more secondary responses");
Steve Frenche4eb2952005-04-28 22:41:09 -0700506 return 1;
Jeff Laytonf5fffce2012-01-17 13:49:17 -0500507 }
508
509 /* we are done */
510 cFYI(1, "found the last secondary response");
511 return 0;
Steve Frenche4eb2952005-04-28 22:41:09 -0700512}
513
Jeff Laytonc74093b2011-01-11 07:24:23 -0500514static void
515cifs_echo_request(struct work_struct *work)
516{
517 int rc;
518 struct TCP_Server_Info *server = container_of(work,
519 struct TCP_Server_Info, echo.work);
520
Jeff Layton247ec9b2011-02-04 17:09:50 -0500521 /*
Jeff Layton195291e2011-02-09 12:01:42 -0500522 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
523 * done, which is indicated by maxBuf != 0. Also, no need to ping if
524 * we got a response recently
Jeff Layton247ec9b2011-02-04 17:09:50 -0500525 */
Jeff Layton195291e2011-02-09 12:01:42 -0500526 if (server->maxBuf == 0 ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500527 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500528 goto requeue_echo;
529
530 rc = CIFSSMBEcho(server);
531 if (rc)
532 cFYI(1, "Unable to send echo request to server: %s",
533 server->hostname);
534
535requeue_echo:
Jeff Laytonda472fc2012-03-23 14:40:53 -0400536 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500537}
538
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400539static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400540allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400541{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400542 if (!server->bigbuf) {
543 server->bigbuf = (char *)cifs_buf_get();
544 if (!server->bigbuf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400545 cERROR(1, "No memory for large SMB response");
546 msleep(3000);
547 /* retry will check if exiting */
548 return false;
549 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400550 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400551 /* we are reusing a dirty large buf, clear its start */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400552 memset(server->bigbuf, 0, header_size());
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400553 }
554
Jeff Layton2a37ef92011-10-19 15:29:23 -0400555 if (!server->smallbuf) {
556 server->smallbuf = (char *)cifs_small_buf_get();
557 if (!server->smallbuf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400558 cERROR(1, "No memory for SMB response");
559 msleep(1000);
560 /* retry will check if exiting */
561 return false;
562 }
563 /* beginning of smb buffer is cleared in our buf_get */
564 } else {
565 /* if existing small buf clear beginning */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400566 memset(server->smallbuf, 0, header_size());
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400567 }
568
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400569 return true;
570}
571
Jeff Laytonba749e62011-10-11 06:41:32 -0400572static bool
573server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400574{
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300575 /*
576 * We need to wait 2 echo intervals to make sure we handle such
577 * situations right:
578 * 1s client sends a normal SMB request
579 * 2s client gets a response
580 * 30s echo workqueue job pops, and decides we got a response recently
581 * and don't need to send another
582 * ...
583 * 65s kernel_recvmsg times out, and we see that we haven't gotten
584 * a response in >60s.
585 */
586 if (server->tcpStatus == CifsGood &&
587 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
Jeff Laytonba749e62011-10-11 06:41:32 -0400588 cERROR(1, "Server %s has not responded in %d seconds. "
589 "Reconnecting...", server->hostname,
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300590 (2 * SMB_ECHO_INTERVAL) / HZ);
Jeff Laytonba749e62011-10-11 06:41:32 -0400591 cifs_reconnect(server);
592 wake_up(&server->response_q);
593 return true;
594 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400595
Jeff Laytonba749e62011-10-11 06:41:32 -0400596 return false;
597}
598
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400599/*
600 * kvec_array_init - clone a kvec array, and advance into it
601 * @new: pointer to memory for cloned array
602 * @iov: pointer to original array
603 * @nr_segs: number of members in original array
604 * @bytes: number of bytes to advance into the cloned array
605 *
606 * This function will copy the array provided in iov to a section of memory
607 * and advance the specified number of bytes into the new array. It returns
608 * the number of segments in the new array. "new" must be at least as big as
609 * the original iov array.
610 */
611static unsigned int
612kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
613 size_t bytes)
614{
615 size_t base = 0;
616
617 while (bytes || !iov->iov_len) {
618 int copy = min(bytes, iov->iov_len);
619
620 bytes -= copy;
621 base += copy;
622 if (iov->iov_len == base) {
623 iov++;
624 nr_segs--;
625 base = 0;
626 }
627 }
628 memcpy(new, iov, sizeof(*iov) * nr_segs);
629 new->iov_base += base;
630 new->iov_len -= base;
631 return nr_segs;
632}
633
Jeff Layton1041e3f2011-10-19 15:28:27 -0400634static struct kvec *
635get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
636{
637 struct kvec *new_iov;
638
639 if (server->iov && nr_segs <= server->nr_iov)
640 return server->iov;
641
642 /* not big enough -- allocate a new one and release the old */
643 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
644 if (new_iov) {
645 kfree(server->iov);
646 server->iov = new_iov;
647 server->nr_iov = nr_segs;
648 }
649 return new_iov;
650}
651
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400652int
653cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
654 unsigned int nr_segs, unsigned int to_read)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400655{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400656 int length = 0;
657 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400658 unsigned int segs;
Jeff Laytone831e6c2011-10-11 06:41:32 -0400659 struct msghdr smb_msg;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400660 struct kvec *iov;
661
Jeff Layton1041e3f2011-10-19 15:28:27 -0400662 iov = get_server_iovec(server, nr_segs);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400663 if (!iov)
664 return -ENOMEM;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400665
Jeff Laytone831e6c2011-10-11 06:41:32 -0400666 smb_msg.msg_control = NULL;
667 smb_msg.msg_controllen = 0;
668
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400669 for (total_read = 0; to_read; total_read += length, to_read -= length) {
Jeff Layton95edcff2011-12-01 20:22:41 -0500670 try_to_freeze();
671
Jeff Laytonba749e62011-10-11 06:41:32 -0400672 if (server_unresponsive(server)) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400673 total_read = -EAGAIN;
Jeff Laytonba749e62011-10-11 06:41:32 -0400674 break;
675 }
676
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400677 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
678
679 length = kernel_recvmsg(server->ssocket, &smb_msg,
680 iov, segs, to_read, 0);
681
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400682 if (server->tcpStatus == CifsExiting) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400683 total_read = -ESHUTDOWN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400684 break;
685 } else if (server->tcpStatus == CifsNeedReconnect) {
686 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400687 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400688 break;
689 } else if (length == -ERESTARTSYS ||
690 length == -EAGAIN ||
691 length == -EINTR) {
692 /*
693 * Minimum sleep to prevent looping, allowing socket
694 * to clear and app threads to set tcpStatus
695 * CifsNeedReconnect if server hung.
696 */
697 usleep_range(1000, 2000);
698 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400699 continue;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400700 } else if (length <= 0) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400701 cFYI(1, "Received no data or error: expecting %d "
702 "got %d", to_read, length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400703 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400704 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400705 break;
706 }
707 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400708 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400709}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400710
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400711int
712cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
713 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400714{
715 struct kvec iov;
716
717 iov.iov_base = buf;
718 iov.iov_len = to_read;
719
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400720 return cifs_readv_from_socket(server, &iov, 1, to_read);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400721}
722
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400723static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400724is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400725{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400726 /*
727 * The first byte big endian of the length field,
728 * is actually not part of the length but the type
729 * with the most common, zero, as regular data.
730 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400731 switch (type) {
732 case RFC1002_SESSION_MESSAGE:
733 /* Regular SMB response */
734 return true;
735 case RFC1002_SESSION_KEEP_ALIVE:
736 cFYI(1, "RFC 1002 session keep alive");
737 break;
738 case RFC1002_POSITIVE_SESSION_RESPONSE:
739 cFYI(1, "RFC 1002 positive session response");
740 break;
741 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400742 /*
743 * We get this from Windows 98 instead of an error on
744 * SMB negprot response.
745 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400746 cFYI(1, "RFC 1002 negative session response");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400747 /* give server a second to clean up */
748 msleep(1000);
749 /*
750 * Always try 445 first on reconnect since we get NACK
751 * on some if we ever connected to port 139 (the NACK
752 * is since we do not begin with RFC1001 session
753 * initialize frame).
754 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400755 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400756 cifs_reconnect(server);
757 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400758 break;
759 default:
760 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400761 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400762 }
763
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400764 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400765}
766
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400767static struct mid_q_entry *
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400768find_mid(struct TCP_Server_Info *server, char *buffer)
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400769{
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400770 struct smb_hdr *buf = (struct smb_hdr *)buffer;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400771 struct mid_q_entry *mid;
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400772
773 spin_lock(&GlobalMid_Lock);
Jeff Laytonea1f4502011-10-19 15:29:05 -0400774 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
775 if (mid->mid == buf->Mid &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400776 mid->mid_state == MID_REQUEST_SUBMITTED &&
777 le16_to_cpu(mid->command) == buf->Command) {
Jeff Laytonea1f4502011-10-19 15:29:05 -0400778 spin_unlock(&GlobalMid_Lock);
779 return mid;
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400780 }
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400781 }
782 spin_unlock(&GlobalMid_Lock);
Jeff Laytonea1f4502011-10-19 15:29:05 -0400783 return NULL;
784}
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400785
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400786void
787dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400788{
789#ifdef CONFIG_CIFS_STATS2
790 mid->when_received = jiffies;
791#endif
792 spin_lock(&GlobalMid_Lock);
793 if (!malformed)
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400794 mid->mid_state = MID_RESPONSE_RECEIVED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400795 else
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400796 mid->mid_state = MID_RESPONSE_MALFORMED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400797 list_del_init(&mid->qhead);
798 spin_unlock(&GlobalMid_Lock);
799}
800
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400801static void
802handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400803 char *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400804{
Jeff Laytonffc00e22011-10-19 15:29:13 -0400805 if (malformed == 0 && check2ndT2(buf) > 0) {
806 mid->multiRsp = true;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400807 if (mid->resp_buf) {
808 /* merge response - fix up 1st*/
Jeff Laytonffc00e22011-10-19 15:29:13 -0400809 malformed = coalesce_t2(buf, mid->resp_buf);
810 if (malformed > 0)
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400811 return;
Jeff Laytonffc00e22011-10-19 15:29:13 -0400812
Jeff Laytonea1f4502011-10-19 15:29:05 -0400813 /* All parts received or packet is malformed. */
814 mid->multiEnd = true;
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400815 return dequeue_mid(mid, malformed);
Jeff Laytonea1f4502011-10-19 15:29:05 -0400816 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400817 if (!server->large_buf) {
Jeff Laytonea1f4502011-10-19 15:29:05 -0400818 /*FIXME: switch to already allocated largebuf?*/
819 cERROR(1, "1st trans2 resp needs bigbuf");
820 } else {
821 /* Have first buffer */
822 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400823 mid->large_buf = true;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400824 server->bigbuf = NULL;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400825 }
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400826 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400827 }
828 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400829 mid->large_buf = server->large_buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400830 /* Was previous buf put in mpx struct for multi-rsp? */
831 if (!mid->multiRsp) {
832 /* smb buffer will be freed by user thread */
833 if (server->large_buf)
834 server->bigbuf = NULL;
835 else
836 server->smallbuf = NULL;
837 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400838 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400839}
840
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400841static void clean_demultiplex_info(struct TCP_Server_Info *server)
842{
843 int length;
844
845 /* take it off the list, if it's not already */
846 spin_lock(&cifs_tcp_ses_lock);
847 list_del_init(&server->tcp_ses_list);
848 spin_unlock(&cifs_tcp_ses_lock);
849
850 spin_lock(&GlobalMid_Lock);
851 server->tcpStatus = CifsExiting;
852 spin_unlock(&GlobalMid_Lock);
853 wake_up_all(&server->response_q);
854
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400855 /* check if we have blocked requests that need to free */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300856 spin_lock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400857 if (server->credits <= 0)
858 server->credits = 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300859 spin_unlock(&server->req_lock);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400860 /*
861 * Although there should not be any requests blocked on this queue it
862 * can not hurt to be paranoid and try to wake up requests that may
863 * haven been blocked when more than 50 at time were on the wire to the
864 * same server - they now will see the session is in exit state and get
865 * out of SendReceive.
866 */
867 wake_up_all(&server->request_q);
868 /* give those requests time to exit */
869 msleep(125);
870
871 if (server->ssocket) {
872 sock_release(server->ssocket);
873 server->ssocket = NULL;
874 }
875
876 if (!list_empty(&server->pending_mid_q)) {
877 struct list_head dispose_list;
878 struct mid_q_entry *mid_entry;
879 struct list_head *tmp, *tmp2;
880
881 INIT_LIST_HEAD(&dispose_list);
882 spin_lock(&GlobalMid_Lock);
883 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
884 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400885 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
886 mid_entry->mid_state = MID_SHUTDOWN;
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400887 list_move(&mid_entry->qhead, &dispose_list);
888 }
889 spin_unlock(&GlobalMid_Lock);
890
891 /* now walk dispose list and issue callbacks */
892 list_for_each_safe(tmp, tmp2, &dispose_list) {
893 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400894 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400895 list_del_init(&mid_entry->qhead);
896 mid_entry->callback(mid_entry);
897 }
898 /* 1/8th of sec is more than enough time for them to exit */
899 msleep(125);
900 }
901
902 if (!list_empty(&server->pending_mid_q)) {
903 /*
904 * mpx threads have not exited yet give them at least the smb
905 * send timeout time for long ops.
906 *
907 * Due to delays on oplock break requests, we need to wait at
908 * least 45 seconds before giving up on a request getting a
909 * response and going ahead and killing cifsd.
910 */
911 cFYI(1, "Wait for exit from demultiplex thread");
912 msleep(46000);
913 /*
914 * If threads still have not exited they are probably never
915 * coming home not much else we can do but free the memory.
916 */
917 }
918
919 kfree(server->hostname);
Jeff Layton1041e3f2011-10-19 15:28:27 -0400920 kfree(server->iov);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400921 kfree(server);
922
923 length = atomic_dec_return(&tcpSesAllocCount);
924 if (length > 0)
925 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
926 GFP_KERNEL);
927}
928
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400929static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400930standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
931{
932 int length;
933 char *buf = server->smallbuf;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400934 unsigned int pdu_length = get_rfc1002_length(buf);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400935
936 /* make sure this will fit in a large buffer */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400937 if (pdu_length > CIFSMaxBufSize + max_header_size() - 4) {
Jeff Laytone9097ab2011-10-19 15:29:40 -0400938 cERROR(1, "SMB response too long (%u bytes)",
939 pdu_length);
940 cifs_reconnect(server);
941 wake_up(&server->response_q);
942 return -EAGAIN;
943 }
944
945 /* switch to large buffer if too big for a small one */
946 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
947 server->large_buf = true;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400948 memcpy(server->bigbuf, buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400949 buf = server->bigbuf;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400950 }
951
952 /* now read the rest */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400953 length = cifs_read_from_socket(server, buf + header_size() - 1,
954 pdu_length - header_size() + 1 + 4);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400955 if (length < 0)
956 return length;
957 server->total_read += length;
958
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400959 dump_smb(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400960
961 /*
962 * We know that we received enough to get to the MID as we
963 * checked the pdu_length earlier. Now check to see
964 * if the rest of the header is OK. We borrow the length
965 * var for the rest of the loop to avoid a new stack var.
966 *
967 * 48 bytes is enough to display the header and a little bit
968 * into the payload for debugging purposes.
969 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400970 length = checkSMB(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400971 if (length != 0)
972 cifs_dump_mem("Bad SMB: ", buf,
973 min_t(unsigned int, server->total_read, 48));
974
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500975 if (!mid)
976 return length;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400977
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400978 handle_mid(mid, server, buf, length);
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500979 return 0;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400980}
981
982static int
Al Viro7c97c202011-06-21 08:51:28 -0400983cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
985 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400986 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400987 unsigned int pdu_length;
988 char *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 struct task_struct *task_to_wake = NULL;
990 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000993 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400994
995 length = atomic_inc_return(&tcpSesAllocCount);
996 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000997 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
998 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
Rafael J. Wysocki83144182007-07-17 04:03:35 -07001000 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +00001001 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -07001002 if (try_to_freeze())
1003 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -07001004
Jeff Layton2a37ef92011-10-19 15:29:23 -04001005 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +04001006 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -07001007
Jeff Layton2a37ef92011-10-19 15:29:23 -04001008 server->large_buf = false;
Jeff Layton2a37ef92011-10-19 15:29:23 -04001009 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +00001010 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +00001011
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001012 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -04001013 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +00001014 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -04001015 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -07001016
Pavel Shilovsky98bac622011-08-01 13:19:42 +04001017 /*
1018 * The right amount was read from socket - 4 bytes,
1019 * so we can now interpret the length field.
1020 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001021 pdu_length = get_rfc1002_length(buf);
Steve French46810cb2005-04-28 22:41:09 -07001022
Jeff Laytonfe11e4c2011-10-11 06:41:32 -04001023 cFYI(1, "RFC1002 header 0x%x", pdu_length);
1024 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001025 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -07001026
Jeff Layton89482a52011-10-19 15:28:57 -04001027 /* make sure we have enough to get to the MID */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001028 if (pdu_length < header_size() - 1 - 4) {
Jeff Layton89482a52011-10-19 15:28:57 -04001029 cERROR(1, "SMB response too short (%u bytes)",
1030 pdu_length);
1031 cifs_reconnect(server);
1032 wake_up(&server->response_q);
1033 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -07001034 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +04001035
Jeff Layton89482a52011-10-19 15:28:57 -04001036 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001037 length = cifs_read_from_socket(server, buf + 4,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001038 header_size() - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -04001039 if (length < 0)
1040 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -04001041 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -04001042
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001043 mid_entry = find_mid(server, buf);
Jeff Laytonc8054eb2011-10-19 15:29:31 -04001044
Jeff Layton44d22d82011-10-19 15:29:49 -04001045 if (!mid_entry || !mid_entry->receive)
1046 length = standard_receive3(server, mid_entry);
1047 else
1048 length = mid_entry->receive(server, mid_entry);
1049
Jeff Laytona52c1eb2011-10-11 06:41:32 -04001050 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -07001051 continue;
1052
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001053 if (server->large_buf)
Jeff Laytone9097ab2011-10-19 15:29:40 -04001054 buf = server->bigbuf;
Steve Frenche4eb2952005-04-28 22:41:09 -07001055
Steve Frenchfda35942011-01-20 18:06:34 +00001056 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -05001057 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -04001058 if (!mid_entry->multiRsp || mid_entry->multiEnd)
1059 mid_entry->callback(mid_entry);
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001060 } else if (!is_valid_oplock_break(buf, server)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001061 cERROR(1, "No task to wake, unknown frame received! "
Jeff Layton80975312011-01-11 07:24:02 -05001062 "NumMids %d", atomic_read(&midCount));
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001063 cifs_dump_mem("Received Data is: ", buf, header_size());
Steve French39798772006-05-31 22:40:51 +00001064#ifdef CONFIG_CIFS_DEBUG2
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001065 cifs_dump_detail(buf);
Steve French39798772006-05-31 22:40:51 +00001066 cifs_dump_mids(server);
1067#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +00001068
Steve Frenche4eb2952005-04-28 22:41:09 -07001069 }
1070 } /* end while !EXITING */
1071
Justin P. Mattockfd62cb72011-02-24 22:15:02 -08001072 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -04001073 cifs_buf_release(server->bigbuf);
1074 if (server->smallbuf) /* no sense logging a debug message if NULL */
1075 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04001077 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +04001078 clean_demultiplex_info(server);
Steve French50c2f752007-07-13 00:33:32 +00001079
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04001080 /* if server->tsk was NULL then wait for a signal before exiting */
1081 if (!task_to_wake) {
1082 set_current_state(TASK_INTERRUPTIBLE);
1083 while (!signal_pending(current)) {
1084 schedule();
1085 set_current_state(TASK_INTERRUPTIBLE);
1086 }
1087 set_current_state(TASK_RUNNING);
1088 }
1089
Jeff Layton0468a2c2008-12-01 07:09:35 -05001090 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091}
1092
Jeff Laytonc359cf32007-11-16 22:22:06 +00001093/* extract the host portion of the UNC string */
1094static char *
1095extract_hostname(const char *unc)
1096{
1097 const char *src;
1098 char *dst, *delim;
1099 unsigned int len;
1100
1101 /* skip double chars at beginning of string */
1102 /* BB: check validity of these bytes? */
1103 src = unc + 2;
1104
1105 /* delimiter between hostname and sharename is always '\\' now */
1106 delim = strchr(src, '\\');
1107 if (!delim)
1108 return ERR_PTR(-EINVAL);
1109
1110 len = delim - src;
1111 dst = kmalloc((len + 1), GFP_KERNEL);
1112 if (dst == NULL)
1113 return ERR_PTR(-ENOMEM);
1114
1115 memcpy(dst, src, len);
1116 dst[len] = '\0';
1117
1118 return dst;
1119}
1120
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001121static int get_option_ul(substring_t args[], unsigned long *option)
1122{
1123 int rc;
1124 char *string;
1125
1126 string = match_strdup(args);
1127 if (string == NULL)
1128 return -ENOMEM;
Sachin Prabhubfa890a2012-04-13 14:04:32 +01001129 rc = kstrtoul(string, 0, option);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001130 kfree(string);
1131
1132 return rc;
1133}
1134
1135
1136static int cifs_parse_security_flavors(char *value,
1137 struct smb_vol *vol)
1138{
1139
1140 substring_t args[MAX_OPT_ARGS];
1141
1142 switch (match_token(value, cifs_secflavor_tokens, args)) {
1143 case Opt_sec_krb5:
1144 vol->secFlg |= CIFSSEC_MAY_KRB5;
1145 break;
1146 case Opt_sec_krb5i:
1147 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1148 break;
1149 case Opt_sec_krb5p:
1150 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1151 cERROR(1, "Krb5 cifs privacy not supported");
1152 break;
1153 case Opt_sec_ntlmssp:
1154 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1155 break;
1156 case Opt_sec_ntlmsspi:
1157 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1158 break;
1159 case Opt_ntlm:
1160 /* ntlm is default so can be turned off too */
1161 vol->secFlg |= CIFSSEC_MAY_NTLM;
1162 break;
1163 case Opt_sec_ntlmi:
1164 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1165 break;
1166 case Opt_sec_nontlm:
1167 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1168 break;
1169 case Opt_sec_ntlmv2i:
1170 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1171 break;
1172#ifdef CONFIG_CIFS_WEAK_PW_HASH
1173 case Opt_sec_lanman:
1174 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1175 break;
1176#endif
1177 case Opt_sec_none:
1178 vol->nullauth = 1;
1179 break;
1180 default:
1181 cERROR(1, "bad security option: %s", value);
1182 return 1;
1183 }
1184
1185 return 0;
1186}
1187
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188static int
Sean Finneyb9468452011-04-11 13:19:32 +00001189cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +00001190 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191{
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001192 char *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +04001193 char *mountdata_copy = NULL, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 unsigned int temp_len, i, j;
1195 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001196 short int override_uid = -1;
1197 short int override_gid = -1;
1198 bool uid_specified = false;
1199 bool gid_specified = false;
Jeff Laytond8162552012-03-23 14:40:56 -04001200 bool sloppy = false;
1201 char *invalid = NULL;
Jeff Layton88463992010-11-22 15:31:03 -05001202 char *nodename = utsname()->nodename;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001203 char *string = NULL;
1204 char *tmp_end, *value;
1205 char delim;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
1207 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +00001208 separator[1] = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001209 delim = separator[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
Jeff Layton88463992010-11-22 15:31:03 -05001211 /*
1212 * does not have to be perfect mapping since field is
1213 * informational, only used for servers that do not support
1214 * port 445 and it can be overridden at mount time
1215 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001216 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1217 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -05001218 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1219
Jeff Layton1397f2e2011-01-07 11:30:28 -05001220 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -07001221 /* null target name indicates to use *SMBSERVR default called name
1222 if we end up sending RFC1001 session initialize */
1223 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001224 vol->cred_uid = current_uid();
1225 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +11001226 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001227
1228 /* default to only allowing write access to owner of the mount */
1229 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -07001232 /* default is always to request posix paths. */
1233 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -04001234 /* default to using server inode numbers where available */
1235 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001236
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301237 vol->actimeo = CIFS_DEF_ACTIMEO;
1238
Sean Finneyb9468452011-04-11 13:19:32 +00001239 if (!mountdata)
1240 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Sean Finneyb9468452011-04-11 13:19:32 +00001242 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1243 if (!mountdata_copy)
1244 goto cifs_parse_mount_err;
1245
1246 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001247 end = options + strlen(options);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001248
Steve French50c2f752007-07-13 00:33:32 +00001249 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001250 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 separator[0] = options[4];
1252 options += 5;
1253 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001254 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 }
1256 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001257 vol->backupuid_specified = false; /* no backup intent for a user */
1258 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +00001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 while ((data = strsep(&options, separator)) != NULL) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001261 substring_t args[MAX_OPT_ARGS];
1262 unsigned long option;
1263 int token;
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 if (!*data)
1266 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001268 token = match_token(data, cifs_mount_option_tokens, args);
1269
1270 switch (token) {
1271
1272 /* Ingnore the following */
1273 case Opt_ignore:
1274 break;
1275
1276 /* Boolean values */
1277 case Opt_user_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 vol->no_xattr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001279 break;
1280 case Opt_nouser_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 vol->no_xattr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001282 break;
1283 case Opt_forceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001284 override_uid = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001285 break;
1286 case Opt_noforceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001287 override_uid = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001288 break;
1289 case Opt_noblocksend:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001290 vol->noblocksnd = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001291 break;
1292 case Opt_noautotune:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001293 vol->noautotune = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001294 break;
1295 case Opt_hard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001297 break;
1298 case Opt_soft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001300 break;
1301 case Opt_perm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 vol->noperm = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001303 break;
1304 case Opt_noperm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 vol->noperm = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001306 break;
1307 case Opt_mapchars:
Steve French6a0b4822005-04-28 22:41:05 -07001308 vol->remap = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001309 break;
1310 case Opt_nomapchars:
Steve French6a0b4822005-04-28 22:41:05 -07001311 vol->remap = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001312 break;
1313 case Opt_sfu:
Steve French50c2f752007-07-13 00:33:32 +00001314 vol->sfu_emul = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001315 break;
1316 case Opt_nosfu:
Steve French50c2f752007-07-13 00:33:32 +00001317 vol->sfu_emul = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001318 break;
1319 case Opt_nodfs:
Steve French2c1b8612008-10-16 18:35:21 +00001320 vol->nodfs = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001321 break;
1322 case Opt_posixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001323 vol->posix_paths = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001324 break;
1325 case Opt_noposixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001326 vol->posix_paths = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001327 break;
1328 case Opt_nounix:
Steve Frenchc18c8422007-07-18 23:21:09 +00001329 vol->no_linux_ext = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001330 break;
1331 case Opt_nocase:
Steve French50c2f752007-07-13 00:33:32 +00001332 vol->nocase = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001333 break;
1334 case Opt_brl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001335 vol->nobrl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001336 break;
1337 case Opt_nobrl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001338 vol->nobrl = 1;
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001339 /*
1340 * turn off mandatory locking in mode
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001341 * if remote locking is turned off since the
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001342 * local vfs will do advisory
1343 */
Steve French50c2f752007-07-13 00:33:32 +00001344 if (vol->file_mode ==
1345 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001346 vol->file_mode = S_IALLUGO;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001347 break;
1348 case Opt_forcemandatorylock:
Steve French13a6e422008-12-02 17:24:33 +00001349 vol->mand_lock = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001350 break;
1351 case Opt_setuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 vol->setuids = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001353 break;
1354 case Opt_nosetuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 vol->setuids = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001356 break;
1357 case Opt_dynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001358 vol->dynperm = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001359 break;
1360 case Opt_nodynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001361 vol->dynperm = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001362 break;
1363 case Opt_nohard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001365 break;
1366 case Opt_nosoft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001368 break;
1369 case Opt_nointr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 vol->intr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001371 break;
1372 case Opt_intr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 vol->intr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001374 break;
1375 case Opt_nostrictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001376 vol->nostrictsync = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001377 break;
1378 case Opt_strictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001379 vol->nostrictsync = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001380 break;
1381 case Opt_serverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 vol->server_ino = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001383 break;
1384 case Opt_noserverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 vol->server_ino = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001386 break;
1387 case Opt_rwpidforward:
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001388 vol->rwpidforward = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001389 break;
1390 case Opt_cifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001391 vol->cifs_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001392 break;
1393 case Opt_nocifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001394 vol->cifs_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001395 break;
1396 case Opt_acl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 vol->no_psx_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001398 break;
1399 case Opt_noacl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 vol->no_psx_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001401 break;
1402 case Opt_locallease:
Steve French84210e92008-10-23 04:42:37 +00001403 vol->local_lease = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001404 break;
1405 case Opt_sign:
Steve French750d1152006-06-27 06:28:30 +00001406 vol->secFlg |= CIFSSEC_MUST_SIGN;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001407 break;
1408 case Opt_seal:
Steve French95b1cb92008-05-15 16:44:38 +00001409 /* we do not do the following in secFlags because seal
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001410 * is a per tree connection (mount) not a per socket
1411 * or per-smb connection option in the protocol
1412 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1413 */
Steve French95b1cb92008-05-15 16:44:38 +00001414 vol->seal = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001415 break;
1416 case Opt_direct:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 vol->direct_io = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001418 break;
1419 case Opt_strictcache:
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05001420 vol->strict_io = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001421 break;
1422 case Opt_noac:
Steve French50c2f752007-07-13 00:33:32 +00001423 printk(KERN_WARNING "CIFS: Mount option noac not "
1424 "supported. Instead set "
1425 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001426 break;
1427 case Opt_fsc:
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301428#ifndef CONFIG_CIFS_FSCACHE
Jeff Layton83fb0862011-06-08 07:35:24 -04001429 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301430 "kernel config option set");
Sean Finneyb9468452011-04-11 13:19:32 +00001431 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301432#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301433 vol->fsc = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001434 break;
1435 case Opt_mfsymlinks:
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001436 vol->mfsymlinks = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001437 break;
1438 case Opt_multiuser:
Jeff Layton0eb8a132010-10-06 19:51:12 -04001439 vol->multiuser = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001440 break;
Jeff Laytond8162552012-03-23 14:40:56 -04001441 case Opt_sloppy:
1442 sloppy = true;
1443 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001444
1445 /* Numeric Values */
1446 case Opt_backupuid:
1447 if (get_option_ul(args, &option)) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001448 cERROR(1, "%s: Invalid backupuid value",
1449 __func__);
1450 goto cifs_parse_mount_err;
1451 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001452 vol->backupuid = option;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001453 vol->backupuid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001454 break;
1455 case Opt_backupgid:
1456 if (get_option_ul(args, &option)) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001457 cERROR(1, "%s: Invalid backupgid value",
1458 __func__);
1459 goto cifs_parse_mount_err;
1460 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001461 vol->backupgid = option;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001462 vol->backupgid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001463 break;
1464 case Opt_uid:
1465 if (get_option_ul(args, &option)) {
1466 cERROR(1, "%s: Invalid uid value",
1467 __func__);
Sean Finneyb9468452011-04-11 13:19:32 +00001468 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001470 vol->linux_uid = option;
1471 uid_specified = true;
1472 break;
1473 case Opt_cruid:
1474 if (get_option_ul(args, &option)) {
1475 cERROR(1, "%s: Invalid cruid value",
1476 __func__);
1477 goto cifs_parse_mount_err;
1478 }
1479 vol->cred_uid = option;
1480 break;
1481 case Opt_gid:
1482 if (get_option_ul(args, &option)) {
1483 cERROR(1, "%s: Invalid gid value",
1484 __func__);
1485 goto cifs_parse_mount_err;
1486 }
1487 vol->linux_gid = option;
1488 gid_specified = true;
1489 break;
1490 case Opt_file_mode:
1491 if (get_option_ul(args, &option)) {
1492 cERROR(1, "%s: Invalid file_mode value",
1493 __func__);
1494 goto cifs_parse_mount_err;
1495 }
1496 vol->file_mode = option;
1497 break;
1498 case Opt_dirmode:
1499 if (get_option_ul(args, &option)) {
1500 cERROR(1, "%s: Invalid dir_mode value",
1501 __func__);
1502 goto cifs_parse_mount_err;
1503 }
1504 vol->dir_mode = option;
1505 break;
1506 case Opt_port:
1507 if (get_option_ul(args, &option)) {
1508 cERROR(1, "%s: Invalid port value",
1509 __func__);
1510 goto cifs_parse_mount_err;
1511 }
1512 vol->port = option;
1513 break;
1514 case Opt_rsize:
1515 if (get_option_ul(args, &option)) {
1516 cERROR(1, "%s: Invalid rsize value",
1517 __func__);
1518 goto cifs_parse_mount_err;
1519 }
1520 vol->rsize = option;
1521 break;
1522 case Opt_wsize:
1523 if (get_option_ul(args, &option)) {
1524 cERROR(1, "%s: Invalid wsize value",
1525 __func__);
1526 goto cifs_parse_mount_err;
1527 }
1528 vol->wsize = option;
1529 break;
1530 case Opt_actimeo:
1531 if (get_option_ul(args, &option)) {
1532 cERROR(1, "%s: Invalid actimeo value",
1533 __func__);
1534 goto cifs_parse_mount_err;
1535 }
1536 vol->actimeo = HZ * option;
1537 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1538 cERROR(1, "CIFS: attribute cache"
1539 "timeout too large");
1540 goto cifs_parse_mount_err;
1541 }
1542 break;
1543
1544 /* String Arguments */
1545
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001546 case Opt_blank_user:
1547 /* null user, ie. anonymous authentication */
1548 vol->nullauth = 1;
1549 vol->username = NULL;
1550 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001551 case Opt_user:
1552 string = match_strdup(args);
1553 if (string == NULL)
1554 goto out_nomem;
1555
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001556 if (strnlen(string, MAX_USERNAME_SIZE) >
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001557 MAX_USERNAME_SIZE) {
1558 printk(KERN_WARNING "CIFS: username too long\n");
1559 goto cifs_parse_mount_err;
1560 }
1561 vol->username = kstrdup(string, GFP_KERNEL);
1562 if (!vol->username) {
1563 printk(KERN_WARNING "CIFS: no memory "
1564 "for username\n");
1565 goto cifs_parse_mount_err;
1566 }
1567 break;
1568 case Opt_blank_pass:
1569 vol->password = NULL;
1570 break;
1571 case Opt_pass:
1572 /* passwords have to be handled differently
1573 * to allow the character used for deliminator
1574 * to be passed within them
1575 */
1576
1577 /* Obtain the value string */
1578 value = strchr(data, '=');
Sachin Prabhu10238072012-03-28 18:07:08 +01001579 value++;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001580
1581 /* Set tmp_end to end of the string */
1582 tmp_end = (char *) value + strlen(value);
1583
1584 /* Check if following character is the deliminator
1585 * If yes, we have encountered a double deliminator
1586 * reset the NULL character to the deliminator
1587 */
1588 if (tmp_end < end && tmp_end[1] == delim)
1589 tmp_end[0] = delim;
1590
1591 /* Keep iterating until we get to a single deliminator
1592 * OR the end
1593 */
1594 while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
1595 (tmp_end[1] == delim)) {
1596 tmp_end = (char *) &tmp_end[2];
1597 }
1598
1599 /* Reset var options to point to next element */
1600 if (tmp_end) {
1601 tmp_end[0] = '\0';
1602 options = (char *) &tmp_end[1];
1603 } else
1604 /* Reached the end of the mount option string */
1605 options = end;
1606
1607 /* Now build new password string */
1608 temp_len = strlen(value);
1609 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1610 if (vol->password == NULL) {
1611 printk(KERN_WARNING "CIFS: no memory "
1612 "for password\n");
1613 goto cifs_parse_mount_err;
1614 }
1615
1616 for (i = 0, j = 0; i < temp_len; i++, j++) {
1617 vol->password[j] = value[i];
1618 if ((value[i] == delim) &&
1619 value[i+1] == delim)
1620 /* skip the second deliminator */
1621 i++;
1622 }
1623 vol->password[j] = '\0';
1624 break;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001625 case Opt_blank_ip:
1626 vol->UNCip = NULL;
1627 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001628 case Opt_ip:
1629 string = match_strdup(args);
1630 if (string == NULL)
1631 goto out_nomem;
1632
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001633 if (strnlen(string, INET6_ADDRSTRLEN) >
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001634 INET6_ADDRSTRLEN) {
1635 printk(KERN_WARNING "CIFS: ip address "
1636 "too long\n");
1637 goto cifs_parse_mount_err;
1638 }
1639 vol->UNCip = kstrdup(string, GFP_KERNEL);
1640 if (!vol->UNCip) {
1641 printk(KERN_WARNING "CIFS: no memory "
1642 "for UNC IP\n");
1643 goto cifs_parse_mount_err;
1644 }
1645 break;
1646 case Opt_unc:
1647 string = match_strdup(args);
1648 if (string == NULL)
1649 goto out_nomem;
1650
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001651 temp_len = strnlen(string, 300);
1652 if (temp_len == 300) {
1653 printk(KERN_WARNING "CIFS: UNC name too long\n");
1654 goto cifs_parse_mount_err;
1655 }
1656
Sachin Prabhue4b41fb2012-04-04 01:58:56 +01001657 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1658 if (vol->UNC == NULL) {
1659 printk(KERN_WARNING "CIFS: no memory for UNC\n");
1660 goto cifs_parse_mount_err;
1661 }
1662 strcpy(vol->UNC, string);
1663
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001664 if (strncmp(string, "//", 2) == 0) {
1665 vol->UNC[0] = '\\';
1666 vol->UNC[1] = '\\';
1667 } else if (strncmp(string, "\\\\", 2) != 0) {
1668 printk(KERN_WARNING "CIFS: UNC Path does not "
1669 "begin with // or \\\\\n");
1670 goto cifs_parse_mount_err;
1671 }
1672
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001673 break;
1674 case Opt_domain:
1675 string = match_strdup(args);
1676 if (string == NULL)
1677 goto out_nomem;
1678
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001679 if (strnlen(string, 256) == 256) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001680 printk(KERN_WARNING "CIFS: domain name too"
1681 " long\n");
1682 goto cifs_parse_mount_err;
1683 }
1684
1685 vol->domainname = kstrdup(string, GFP_KERNEL);
1686 if (!vol->domainname) {
1687 printk(KERN_WARNING "CIFS: no memory "
1688 "for domainname\n");
1689 goto cifs_parse_mount_err;
1690 }
1691 cFYI(1, "Domain name set");
1692 break;
1693 case Opt_srcaddr:
1694 string = match_strdup(args);
1695 if (string == NULL)
1696 goto out_nomem;
1697
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001698 if (!cifs_convert_address(
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001699 (struct sockaddr *)&vol->srcaddr,
1700 string, strlen(string))) {
1701 printk(KERN_WARNING "CIFS: Could not parse"
1702 " srcaddr: %s\n", string);
1703 goto cifs_parse_mount_err;
1704 }
1705 break;
1706 case Opt_prefixpath:
1707 string = match_strdup(args);
1708 if (string == NULL)
1709 goto out_nomem;
1710
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001711 temp_len = strnlen(string, 1024);
1712 if (string[0] != '/')
1713 temp_len++; /* missing leading slash */
1714 if (temp_len > 1024) {
1715 printk(KERN_WARNING "CIFS: prefix too long\n");
1716 goto cifs_parse_mount_err;
1717 }
1718
1719 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1720 if (vol->prepath == NULL) {
1721 printk(KERN_WARNING "CIFS: no memory "
1722 "for path prefix\n");
1723 goto cifs_parse_mount_err;
1724 }
1725
1726 if (string[0] != '/') {
1727 vol->prepath[0] = '/';
1728 strcpy(vol->prepath+1, string);
1729 } else
1730 strcpy(vol->prepath, string);
1731
1732 break;
1733 case Opt_iocharset:
1734 string = match_strdup(args);
1735 if (string == NULL)
1736 goto out_nomem;
1737
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001738 if (strnlen(string, 1024) >= 65) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001739 printk(KERN_WARNING "CIFS: iocharset name "
1740 "too long.\n");
1741 goto cifs_parse_mount_err;
1742 }
1743
1744 if (strnicmp(string, "default", 7) != 0) {
1745 vol->iocharset = kstrdup(string,
1746 GFP_KERNEL);
1747 if (!vol->iocharset) {
1748 printk(KERN_WARNING "CIFS: no memory"
1749 "for charset\n");
1750 goto cifs_parse_mount_err;
1751 }
1752 }
1753 /* if iocharset not set then load_nls_default
1754 * is used by caller
1755 */
1756 cFYI(1, "iocharset set to %s", string);
1757 break;
1758 case Opt_sockopt:
1759 string = match_strdup(args);
1760 if (string == NULL)
1761 goto out_nomem;
1762
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001763 if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1764 vol->sockopt_tcp_nodelay = 1;
1765 break;
1766 case Opt_netbiosname:
1767 string = match_strdup(args);
1768 if (string == NULL)
1769 goto out_nomem;
1770
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001771 memset(vol->source_rfc1001_name, 0x20,
1772 RFC1001_NAME_LEN);
1773 /*
1774 * FIXME: are there cases in which a comma can
1775 * be valid in workstation netbios name (and
1776 * need special handling)?
1777 */
1778 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1779 /* don't ucase netbiosname for user */
1780 if (string[i] == 0)
1781 break;
1782 vol->source_rfc1001_name[i] = string[i];
1783 }
1784 /* The string has 16th byte zero still from
1785 * set at top of the function
1786 */
1787 if (i == RFC1001_NAME_LEN && string[i] != 0)
1788 printk(KERN_WARNING "CIFS: netbiosname"
1789 " longer than 15 truncated.\n");
1790
1791 break;
1792 case Opt_servern:
1793 /* servernetbiosname specified override *SMBSERVER */
1794 string = match_strdup(args);
1795 if (string == NULL)
1796 goto out_nomem;
1797
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001798 /* last byte, type, is 0x20 for servr type */
1799 memset(vol->target_rfc1001_name, 0x20,
1800 RFC1001_NAME_LEN_WITH_NULL);
1801
1802 /* BB are there cases in which a comma can be
1803 valid in this workstation netbios name
1804 (and need special handling)? */
1805
1806 /* user or mount helper must uppercase the
1807 netbios name */
1808 for (i = 0; i < 15; i++) {
1809 if (string[i] == 0)
1810 break;
1811 vol->target_rfc1001_name[i] = string[i];
1812 }
1813 /* The string has 16th byte zero still from
1814 set at top of the function */
1815 if (i == RFC1001_NAME_LEN && string[i] != 0)
1816 printk(KERN_WARNING "CIFS: server net"
1817 "biosname longer than 15 truncated.\n");
1818 break;
1819 case Opt_ver:
1820 string = match_strdup(args);
1821 if (string == NULL)
1822 goto out_nomem;
1823
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001824 if (strnicmp(string, "cifs", 4) == 0 ||
1825 strnicmp(string, "1", 1) == 0) {
1826 /* This is the default */
1827 break;
1828 }
1829 /* For all other value, error */
1830 printk(KERN_WARNING "CIFS: Invalid version"
1831 " specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001832 goto cifs_parse_mount_err;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001833 case Opt_sec:
1834 string = match_strdup(args);
1835 if (string == NULL)
1836 goto out_nomem;
1837
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001838 if (cifs_parse_security_flavors(string, vol) != 0)
1839 goto cifs_parse_mount_err;
1840 break;
1841 default:
Jeff Laytond8162552012-03-23 14:40:56 -04001842 /*
1843 * An option we don't recognize. Save it off for later
1844 * if we haven't already found one
1845 */
1846 if (!invalid)
1847 invalid = data;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001848 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001850 /* Free up any allocated string */
1851 kfree(string);
1852 string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001854
Jeff Laytond8162552012-03-23 14:40:56 -04001855 if (!sloppy && invalid) {
1856 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1857 goto cifs_parse_mount_err;
1858 }
1859
Jeff Layton8a8798a2012-01-17 16:09:15 -05001860#ifndef CONFIG_KEYS
1861 /* Muliuser mounts require CONFIG_KEYS support */
1862 if (vol->multiuser) {
1863 cERROR(1, "Multiuser mounts require kernels with "
1864 "CONFIG_KEYS enabled.");
Sean Finneyb9468452011-04-11 13:19:32 +00001865 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001866 }
Jeff Layton8a8798a2012-01-17 16:09:15 -05001867#endif
Jeff Layton0eb8a132010-10-06 19:51:12 -04001868
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001869 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 vol->UNCip = &vol->UNC[2];
1871
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001872 if (uid_specified)
1873 vol->override_uid = override_uid;
1874 else if (override_uid == 1)
1875 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1876 "specified with no uid= option.\n");
1877
1878 if (gid_specified)
1879 vol->override_gid = override_gid;
1880 else if (override_gid == 1)
1881 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1882 "specified with no gid= option.\n");
1883
Sean Finneyb9468452011-04-11 13:19:32 +00001884 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001886
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001887out_nomem:
1888 printk(KERN_WARNING "Could not allocate temporary buffer\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001889cifs_parse_mount_err:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001890 kfree(string);
Sean Finneyb9468452011-04-11 13:19:32 +00001891 kfree(mountdata_copy);
1892 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893}
1894
Ben Greear3eb9a882010-09-01 17:06:02 -07001895/** Returns true if srcaddr isn't specified and rhs isn't
1896 * specified, or if srcaddr is specified and
1897 * matches the IP address of the rhs argument.
1898 */
Jeff Layton45151482010-07-06 20:43:02 -04001899static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001900srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1901{
1902 switch (srcaddr->sa_family) {
1903 case AF_UNSPEC:
1904 return (rhs->sa_family == AF_UNSPEC);
1905 case AF_INET: {
1906 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1907 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1908 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1909 }
1910 case AF_INET6: {
1911 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1912 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1913 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1914 }
1915 default:
1916 WARN_ON(1);
1917 return false; /* don't expect to be here */
1918 }
1919}
1920
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001921/*
1922 * If no port is specified in addr structure, we try to match with 445 port
1923 * and if it fails - with 139 ports. It should be called only if address
1924 * families of server and addr are equal.
1925 */
1926static bool
1927match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1928{
Steve French6da97912011-03-13 18:55:55 +00001929 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001930
1931 switch (addr->sa_family) {
1932 case AF_INET:
1933 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1934 port = ((struct sockaddr_in *) addr)->sin_port;
1935 break;
1936 case AF_INET6:
1937 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1938 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1939 break;
1940 default:
1941 WARN_ON(1);
1942 return false;
1943 }
1944
1945 if (!port) {
1946 port = htons(CIFS_PORT);
1947 if (port == *sport)
1948 return true;
1949
1950 port = htons(RFC1001_PORT);
1951 }
1952
1953 return port == *sport;
1954}
Ben Greear3eb9a882010-09-01 17:06:02 -07001955
1956static bool
1957match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1958 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959{
Jeff Layton45151482010-07-06 20:43:02 -04001960 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001961 case AF_INET: {
1962 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1963 struct sockaddr_in *srv_addr4 =
1964 (struct sockaddr_in *)&server->dstaddr;
1965
1966 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001967 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001968 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001969 }
1970 case AF_INET6: {
1971 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1972 struct sockaddr_in6 *srv_addr6 =
1973 (struct sockaddr_in6 *)&server->dstaddr;
1974
Jeff Layton45151482010-07-06 20:43:02 -04001975 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001976 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001977 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001978 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001979 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001980 break;
1981 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001982 default:
1983 WARN_ON(1);
1984 return false; /* don't expect to be here */
1985 }
Jeff Layton45151482010-07-06 20:43:02 -04001986
Ben Greear3eb9a882010-09-01 17:06:02 -07001987 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1988 return false;
1989
Jeff Layton45151482010-07-06 20:43:02 -04001990 return true;
1991}
1992
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001993static bool
1994match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1995{
1996 unsigned int secFlags;
1997
1998 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1999 secFlags = vol->secFlg;
2000 else
2001 secFlags = global_secflags | vol->secFlg;
2002
2003 switch (server->secType) {
2004 case LANMAN:
2005 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2006 return false;
2007 break;
2008 case NTLMv2:
2009 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2010 return false;
2011 break;
2012 case NTLM:
2013 if (!(secFlags & CIFSSEC_MAY_NTLM))
2014 return false;
2015 break;
2016 case Kerberos:
2017 if (!(secFlags & CIFSSEC_MAY_KRB5))
2018 return false;
2019 break;
2020 case RawNTLMSSP:
2021 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2022 return false;
2023 break;
2024 default:
2025 /* shouldn't happen */
2026 return false;
2027 }
2028
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002029 /* now check if signing mode is acceptable */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002030 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
Steve French96daf2b2011-05-27 04:34:02 +00002031 (server->sec_mode & SECMODE_SIGN_REQUIRED))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002032 return false;
2033 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
Steve French96daf2b2011-05-27 04:34:02 +00002034 (server->sec_mode &
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002035 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2036 return false;
2037
2038 return true;
2039}
2040
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002041static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
2042 struct smb_vol *vol)
2043{
2044 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2045 return 0;
2046
2047 if (!match_address(server, addr,
2048 (struct sockaddr *)&vol->srcaddr))
2049 return 0;
2050
2051 if (!match_port(server, addr))
2052 return 0;
2053
2054 if (!match_security(server, vol))
2055 return 0;
2056
2057 return 1;
2058}
2059
Jeff Layton45151482010-07-06 20:43:02 -04002060static struct TCP_Server_Info *
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002061cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04002062{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002063 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302065 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04002066 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002067 if (!match_server(server, addr, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002068 continue;
2069
Jeff Laytone7ddee92008-11-14 13:44:38 -05002070 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302071 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002072 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05002073 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302075 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 return NULL;
2077}
2078
Jeff Layton14fbf502008-11-14 13:53:46 -05002079static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05002080cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002082 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302084 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002085 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302086 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002087 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 }
Steve Frenchdea570e2008-05-06 22:05:51 +00002089
Rob Landleyf1d0c992011-01-22 15:44:05 -06002090 put_net(cifs_net_ns(server));
2091
Jeff Laytone7ddee92008-11-14 13:44:38 -05002092 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302093 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002094
Jeff Laytonc74093b2011-01-11 07:24:23 -05002095 cancel_delayed_work_sync(&server->echo);
2096
Jeff Laytone7ddee92008-11-14 13:44:38 -05002097 spin_lock(&GlobalMid_Lock);
2098 server->tcpStatus = CifsExiting;
2099 spin_unlock(&GlobalMid_Lock);
2100
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002101 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302102 cifs_fscache_release_client_cookie(server);
2103
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05002104 kfree(server->session_key.response);
2105 server->session_key.response = NULL;
2106 server->session_key.len = 0;
2107
Jeff Laytone7ddee92008-11-14 13:44:38 -05002108 task = xchg(&server->tsk, NULL);
2109 if (task)
2110 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111}
2112
Jeff Layton63c038c2008-12-01 18:41:46 -05002113static struct TCP_Server_Info *
2114cifs_get_tcp_session(struct smb_vol *volume_info)
2115{
2116 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05002117 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05002118 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2119 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2120 int rc;
2121
Jeff Laytona9ac49d2009-01-22 14:43:21 -05002122 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05002123
Joe Perchesb6b38f72010-04-21 03:50:45 +00002124 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04002125
Jeff Layton63c038c2008-12-01 18:41:46 -05002126 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton50d97162010-07-06 20:43:01 -04002127 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2128 volume_info->UNCip,
David Howells67b76262010-07-22 18:33:01 +01002129 strlen(volume_info->UNCip),
Jeff Layton50d97162010-07-06 20:43:01 -04002130 volume_info->port);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04002131 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05002132 /* we failed translating address */
2133 rc = -EINVAL;
2134 goto out_err;
2135 }
Jeff Layton63c038c2008-12-01 18:41:46 -05002136 } else if (volume_info->UNCip) {
2137 /* BB using ip addr as tcp_ses name to connect to the
2138 DFS root below */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002139 cERROR(1, "Connecting to DFS root not implemented yet");
Jeff Layton63c038c2008-12-01 18:41:46 -05002140 rc = -EINVAL;
2141 goto out_err;
2142 } else /* which tcp_sess DFS root would we conect to */ {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002143 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2144 "unc=//192.168.1.100/public) specified");
Jeff Layton63c038c2008-12-01 18:41:46 -05002145 rc = -EINVAL;
2146 goto out_err;
2147 }
2148
2149 /* see if we already have a matching tcp_ses */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002150 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002151 if (tcp_ses)
2152 return tcp_ses;
2153
2154 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2155 if (!tcp_ses) {
2156 rc = -ENOMEM;
2157 goto out_err;
2158 }
2159
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002160 rc = cifs_crypto_shash_allocate(tcp_ses);
2161 if (rc) {
2162 cERROR(1, "could not setup hash structures rc %d", rc);
2163 goto out_err;
2164 }
2165
Rob Landleyf1d0c992011-01-22 15:44:05 -06002166 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05002167 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2168 if (IS_ERR(tcp_ses->hostname)) {
2169 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002170 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002171 }
2172
2173 tcp_ses->noblocksnd = volume_info->noblocksnd;
2174 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00002175 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +03002176 tcp_ses->in_flight = 0;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002177 tcp_ses->credits = 1;
Jeff Layton63c038c2008-12-01 18:41:46 -05002178 init_waitqueue_head(&tcp_ses->response_q);
2179 init_waitqueue_head(&tcp_ses->request_q);
2180 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2181 mutex_init(&tcp_ses->srv_mutex);
2182 memcpy(tcp_ses->workstation_RFC1001_name,
2183 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2184 memcpy(tcp_ses->server_RFC1001_name,
2185 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05002186 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05002187 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00002188 tcp_ses->lstrp = jiffies;
Jeff Layton58fa0152012-05-01 17:41:16 -04002189 spin_lock_init(&tcp_ses->req_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002190 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2191 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002192 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton63c038c2008-12-01 18:41:46 -05002193
2194 /*
2195 * at this point we are the only ones with the pointer
2196 * to the struct since the kernel thread not created yet
2197 * no need to spinlock this init of tcpStatus or srv_count
2198 */
2199 tcp_ses->tcpStatus = CifsNew;
Ben Greear3eb9a882010-09-01 17:06:02 -07002200 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2201 sizeof(tcp_ses->srcaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05002202 ++tcp_ses->srv_count;
2203
Jeff Laytona9ac49d2009-01-22 14:43:21 -05002204 if (addr.ss_family == AF_INET6) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002205 cFYI(1, "attempting ipv6 connect");
Jeff Layton63c038c2008-12-01 18:41:46 -05002206 /* BB should we allow ipv6 on port 139? */
2207 /* other OS never observed in Wild doing 139 with v6 */
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002208 memcpy(&tcp_ses->dstaddr, sin_server6,
2209 sizeof(struct sockaddr_in6));
2210 } else
2211 memcpy(&tcp_ses->dstaddr, sin_server,
2212 sizeof(struct sockaddr_in));
2213
2214 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05002215 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002216 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002217 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002218 }
2219
2220 /*
2221 * since we're in a cifs function already, we know that
2222 * this will succeed. No need for try_module_get().
2223 */
2224 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04002225 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05002226 tcp_ses, "cifsd");
2227 if (IS_ERR(tcp_ses->tsk)) {
2228 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002229 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05002230 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002231 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002232 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00002233 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05002234
2235 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302236 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002237 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302238 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002239
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302240 cifs_fscache_get_client_cookie(tcp_ses);
2241
Jeff Laytonc74093b2011-01-11 07:24:23 -05002242 /* queue echo request delayed work */
Jeff Laytonda472fc2012-03-23 14:40:53 -04002243 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002244
Jeff Layton63c038c2008-12-01 18:41:46 -05002245 return tcp_ses;
2246
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002247out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002248 cifs_crypto_shash_release(tcp_ses);
2249
Rob Landleyf1d0c992011-01-22 15:44:05 -06002250 put_net(cifs_net_ns(tcp_ses));
2251
Jeff Layton63c038c2008-12-01 18:41:46 -05002252out_err:
2253 if (tcp_ses) {
Steve French8347a5cd2009-10-06 18:31:29 +00002254 if (!IS_ERR(tcp_ses->hostname))
2255 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05002256 if (tcp_ses->ssocket)
2257 sock_release(tcp_ses->ssocket);
2258 kfree(tcp_ses);
2259 }
2260 return ERR_PTR(rc);
2261}
2262
Steve French96daf2b2011-05-27 04:34:02 +00002263static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002264{
2265 switch (ses->server->secType) {
2266 case Kerberos:
2267 if (vol->cred_uid != ses->cred_uid)
2268 return 0;
2269 break;
2270 default:
Jeff Layton04febab2012-01-17 16:09:15 -05002271 /* NULL username means anonymous session */
2272 if (ses->user_name == NULL) {
2273 if (!vol->nullauth)
2274 return 0;
2275 break;
2276 }
2277
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002278 /* anything else takes username/password */
Jeff Layton04febab2012-01-17 16:09:15 -05002279 if (strncmp(ses->user_name,
2280 vol->username ? vol->username : "",
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002281 MAX_USERNAME_SIZE))
2282 return 0;
2283 if (strlen(vol->username) != 0 &&
2284 ses->password != NULL &&
2285 strncmp(ses->password,
2286 vol->password ? vol->password : "",
2287 MAX_PASSWORD_SIZE))
2288 return 0;
2289 }
2290 return 1;
2291}
2292
Steve French96daf2b2011-05-27 04:34:02 +00002293static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04002294cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295{
Steve French96daf2b2011-05-27 04:34:02 +00002296 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302298 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002299 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002300 if (!match_session(ses, vol))
2301 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002302 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302303 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002304 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302306 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 return NULL;
2308}
2309
Jeff Layton14fbf502008-11-14 13:53:46 -05002310static void
Steve French96daf2b2011-05-27 04:34:02 +00002311cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002312{
2313 int xid;
2314 struct TCP_Server_Info *server = ses->server;
2315
Jeff Layton36988c72010-04-24 07:57:43 -04002316 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302317 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002318 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302319 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002320 return;
2321 }
2322
2323 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302324 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002325
2326 if (ses->status == CifsGood) {
2327 xid = GetXid();
2328 CIFSSMBLogoff(xid, ses);
2329 _FreeXid(xid);
2330 }
2331 sesInfoFree(ses);
2332 cifs_put_tcp_session(server);
2333}
2334
Jeff Layton8a8798a2012-01-17 16:09:15 -05002335#ifdef CONFIG_KEYS
2336
2337/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2338#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2339
2340/* Populate username and pw fields from keyring if possible */
2341static int
2342cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2343{
2344 int rc = 0;
2345 char *desc, *delim, *payload;
2346 ssize_t len;
2347 struct key *key;
2348 struct TCP_Server_Info *server = ses->server;
2349 struct sockaddr_in *sa;
2350 struct sockaddr_in6 *sa6;
2351 struct user_key_payload *upayload;
2352
2353 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2354 if (!desc)
2355 return -ENOMEM;
2356
2357 /* try to find an address key first */
2358 switch (server->dstaddr.ss_family) {
2359 case AF_INET:
2360 sa = (struct sockaddr_in *)&server->dstaddr;
2361 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2362 break;
2363 case AF_INET6:
2364 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2365 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2366 break;
2367 default:
2368 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2369 rc = -EINVAL;
2370 goto out_err;
2371 }
2372
2373 cFYI(1, "%s: desc=%s", __func__, desc);
2374 key = request_key(&key_type_logon, desc, "");
2375 if (IS_ERR(key)) {
2376 if (!ses->domainName) {
2377 cFYI(1, "domainName is NULL");
2378 rc = PTR_ERR(key);
2379 goto out_err;
2380 }
2381
2382 /* didn't work, try to find a domain key */
2383 sprintf(desc, "cifs:d:%s", ses->domainName);
2384 cFYI(1, "%s: desc=%s", __func__, desc);
2385 key = request_key(&key_type_logon, desc, "");
2386 if (IS_ERR(key)) {
2387 rc = PTR_ERR(key);
2388 goto out_err;
2389 }
2390 }
2391
2392 down_read(&key->sem);
2393 upayload = key->payload.data;
2394 if (IS_ERR_OR_NULL(upayload)) {
Jeff Layton4edc53c2012-02-07 06:30:51 -05002395 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002396 goto out_key_put;
2397 }
2398
2399 /* find first : in payload */
2400 payload = (char *)upayload->data;
2401 delim = strnchr(payload, upayload->datalen, ':');
2402 cFYI(1, "payload=%s", payload);
2403 if (!delim) {
2404 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2405 upayload->datalen);
2406 rc = -EINVAL;
2407 goto out_key_put;
2408 }
2409
2410 len = delim - payload;
2411 if (len > MAX_USERNAME_SIZE || len <= 0) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002412 cFYI(1, "Bad value from username search (len=%zd)", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002413 rc = -EINVAL;
2414 goto out_key_put;
2415 }
2416
2417 vol->username = kstrndup(payload, len, GFP_KERNEL);
2418 if (!vol->username) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002419 cFYI(1, "Unable to allocate %zd bytes for username", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002420 rc = -ENOMEM;
2421 goto out_key_put;
2422 }
2423 cFYI(1, "%s: username=%s", __func__, vol->username);
2424
2425 len = key->datalen - (len + 1);
2426 if (len > MAX_PASSWORD_SIZE || len <= 0) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002427 cFYI(1, "Bad len for password search (len=%zd)", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002428 rc = -EINVAL;
2429 kfree(vol->username);
2430 vol->username = NULL;
2431 goto out_key_put;
2432 }
2433
2434 ++delim;
2435 vol->password = kstrndup(delim, len, GFP_KERNEL);
2436 if (!vol->password) {
Randy Dunlap000f9bb2012-01-30 19:50:01 -08002437 cFYI(1, "Unable to allocate %zd bytes for password", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002438 rc = -ENOMEM;
2439 kfree(vol->username);
2440 vol->username = NULL;
2441 goto out_key_put;
2442 }
2443
2444out_key_put:
2445 up_read(&key->sem);
2446 key_put(key);
2447out_err:
2448 kfree(desc);
2449 cFYI(1, "%s: returning %d", __func__, rc);
2450 return rc;
2451}
2452#else /* ! CONFIG_KEYS */
2453static inline int
2454cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2455 struct cifs_ses *ses __attribute__((unused)))
2456{
2457 return -ENOSYS;
2458}
2459#endif /* CONFIG_KEYS */
2460
Steve Frenchd9b94202011-04-12 01:24:57 +00002461static bool warned_on_ntlm; /* globals init to false automatically */
2462
Steve French96daf2b2011-05-27 04:34:02 +00002463static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002464cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2465{
2466 int rc = -ENOMEM, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002467 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002468 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2469 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002470
2471 xid = GetXid();
2472
Jeff Layton4ff67b72010-07-06 20:43:02 -04002473 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002474 if (ses) {
2475 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2476
Jeff Layton36988c72010-04-24 07:57:43 -04002477 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002478 rc = cifs_negotiate_protocol(xid, ses);
2479 if (rc) {
2480 mutex_unlock(&ses->session_mutex);
2481 /* problem -- put our ses reference */
2482 cifs_put_smb_ses(ses);
2483 FreeXid(xid);
2484 return ERR_PTR(rc);
2485 }
Jeff Layton36988c72010-04-24 07:57:43 -04002486 if (ses->need_reconnect) {
2487 cFYI(1, "Session needs reconnect");
2488 rc = cifs_setup_session(xid, ses,
2489 volume_info->local_nls);
2490 if (rc) {
2491 mutex_unlock(&ses->session_mutex);
2492 /* problem -- put our reference */
2493 cifs_put_smb_ses(ses);
2494 FreeXid(xid);
2495 return ERR_PTR(rc);
2496 }
2497 }
2498 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002499
2500 /* existing SMB ses has a server reference already */
2501 cifs_put_tcp_session(server);
Jeff Layton36988c72010-04-24 07:57:43 -04002502 FreeXid(xid);
2503 return ses;
2504 }
2505
2506 cFYI(1, "Existing smb sess not found");
2507 ses = sesInfoAlloc();
2508 if (ses == NULL)
2509 goto get_ses_fail;
2510
2511 /* new SMB session uses our server ref */
2512 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002513 if (server->dstaddr.ss_family == AF_INET6)
2514 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002515 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002516 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002517
Steve French8727c8a2011-02-25 01:11:56 -06002518 if (volume_info->username) {
2519 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2520 if (!ses->user_name)
2521 goto get_ses_fail;
2522 }
Jeff Layton36988c72010-04-24 07:57:43 -04002523
2524 /* volume_info->password freed at unmount */
2525 if (volume_info->password) {
2526 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2527 if (!ses->password)
2528 goto get_ses_fail;
2529 }
2530 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002531 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2532 if (!ses->domainName)
2533 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002534 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002535 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002536 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002537
2538 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2539 supported for many years, time to update default security mechanism */
2540 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2541 warned_on_ntlm = true;
2542 cERROR(1, "default security mechanism requested. The default "
2543 "security mechanism will be upgraded from ntlm to "
Steve French225de112012-01-03 23:08:24 -06002544 "ntlmv2 in kernel release 3.3");
Steve Frenchd9b94202011-04-12 01:24:57 +00002545 }
Jeff Layton36988c72010-04-24 07:57:43 -04002546 ses->overrideSecFlg = volume_info->secFlg;
2547
2548 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002549 rc = cifs_negotiate_protocol(xid, ses);
2550 if (!rc)
2551 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002552 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002553 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002554 goto get_ses_fail;
2555
2556 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302557 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002558 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302559 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002560
2561 FreeXid(xid);
2562 return ses;
2563
2564get_ses_fail:
2565 sesInfoFree(ses);
2566 FreeXid(xid);
2567 return ERR_PTR(rc);
2568}
2569
Steve French96daf2b2011-05-27 04:34:02 +00002570static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002571{
2572 if (tcon->tidStatus == CifsExiting)
2573 return 0;
2574 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2575 return 0;
2576 return 1;
2577}
2578
Steve French96daf2b2011-05-27 04:34:02 +00002579static struct cifs_tcon *
2580cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581{
2582 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002583 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302585 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002586 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002587 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002588 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002589 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002590 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302591 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 return tcon;
2593 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302594 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 return NULL;
2596}
2597
Jeff Laytonf1987b42008-11-15 11:12:47 -05002598static void
Steve French96daf2b2011-05-27 04:34:02 +00002599cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002600{
2601 int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002602 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002603
Jeff Laytond00c28d2010-04-24 07:57:44 -04002604 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302605 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002606 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302607 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002608 return;
2609 }
2610
2611 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302612 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002613
2614 xid = GetXid();
2615 CIFSSMBTDis(xid, tcon);
2616 _FreeXid(xid);
2617
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302618 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002619 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002620 cifs_put_smb_ses(ses);
2621}
2622
Steve French96daf2b2011-05-27 04:34:02 +00002623static struct cifs_tcon *
2624cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002625{
2626 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002627 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002628
2629 tcon = cifs_find_tcon(ses, volume_info->UNC);
2630 if (tcon) {
2631 cFYI(1, "Found match on UNC path");
2632 /* existing tcon already has a reference */
2633 cifs_put_smb_ses(ses);
2634 if (tcon->seal != volume_info->seal)
2635 cERROR(1, "transport encryption setting "
2636 "conflicts with existing tid");
2637 return tcon;
2638 }
2639
2640 tcon = tconInfoAlloc();
2641 if (tcon == NULL) {
2642 rc = -ENOMEM;
2643 goto out_fail;
2644 }
2645
2646 tcon->ses = ses;
2647 if (volume_info->password) {
2648 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2649 if (!tcon->password) {
2650 rc = -ENOMEM;
2651 goto out_fail;
2652 }
2653 }
2654
2655 if (strchr(volume_info->UNC + 3, '\\') == NULL
2656 && strchr(volume_info->UNC + 3, '/') == NULL) {
2657 cERROR(1, "Missing share name");
2658 rc = -ENODEV;
2659 goto out_fail;
2660 }
2661
2662 /* BB Do we need to wrap session_mutex around
2663 * this TCon call and Unix SetFS as
2664 * we do on SessSetup and reconnect? */
2665 xid = GetXid();
2666 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2667 FreeXid(xid);
2668 cFYI(1, "CIFS Tcon rc = %d", rc);
2669 if (rc)
2670 goto out_fail;
2671
2672 if (volume_info->nodfs) {
2673 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2674 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2675 }
2676 tcon->seal = volume_info->seal;
2677 /* we can have only one retry value for a connection
2678 to a share so for resources mounted more than once
2679 to the same server share the last value passed in
2680 for the retry flag is used */
2681 tcon->retry = volume_info->retry;
2682 tcon->nocase = volume_info->nocase;
2683 tcon->local_lease = volume_info->local_lease;
2684
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302685 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002686 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302687 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002688
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302689 cifs_fscache_get_super_cookie(tcon);
2690
Jeff Laytond00c28d2010-04-24 07:57:44 -04002691 return tcon;
2692
2693out_fail:
2694 tconInfoFree(tcon);
2695 return ERR_PTR(rc);
2696}
2697
Jeff Layton9d002df2010-10-06 19:51:11 -04002698void
2699cifs_put_tlink(struct tcon_link *tlink)
2700{
2701 if (!tlink || IS_ERR(tlink))
2702 return;
2703
2704 if (!atomic_dec_and_test(&tlink->tl_count) ||
2705 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2706 tlink->tl_time = jiffies;
2707 return;
2708 }
2709
2710 if (!IS_ERR(tlink_tcon(tlink)))
2711 cifs_put_tcon(tlink_tcon(tlink));
2712 kfree(tlink);
2713 return;
2714}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002715
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002716static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002717cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2718{
2719 return cifs_sb->master_tlink;
2720}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002721
2722static int
2723compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2724{
2725 struct cifs_sb_info *old = CIFS_SB(sb);
2726 struct cifs_sb_info *new = mnt_data->cifs_sb;
2727
2728 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2729 return 0;
2730
2731 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2732 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2733 return 0;
2734
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002735 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002736 * We want to share sb only if we don't specify an r/wsize or
2737 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002738 */
2739 if (new->wsize && new->wsize < old->wsize)
2740 return 0;
2741
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002742 if (new->rsize && new->rsize < old->rsize)
2743 return 0;
2744
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002745 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2746 return 0;
2747
2748 if (old->mnt_file_mode != new->mnt_file_mode ||
2749 old->mnt_dir_mode != new->mnt_dir_mode)
2750 return 0;
2751
2752 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2753 return 0;
2754
2755 if (old->actimeo != new->actimeo)
2756 return 0;
2757
2758 return 1;
2759}
2760
2761int
2762cifs_match_super(struct super_block *sb, void *data)
2763{
2764 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2765 struct smb_vol *volume_info;
2766 struct cifs_sb_info *cifs_sb;
2767 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002768 struct cifs_ses *ses;
2769 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002770 struct tcon_link *tlink;
2771 struct sockaddr_storage addr;
2772 int rc = 0;
2773
2774 memset(&addr, 0, sizeof(struct sockaddr_storage));
2775
2776 spin_lock(&cifs_tcp_ses_lock);
2777 cifs_sb = CIFS_SB(sb);
2778 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2779 if (IS_ERR(tlink)) {
2780 spin_unlock(&cifs_tcp_ses_lock);
2781 return rc;
2782 }
2783 tcon = tlink_tcon(tlink);
2784 ses = tcon->ses;
2785 tcp_srv = ses->server;
2786
2787 volume_info = mnt_data->vol;
2788
2789 if (!volume_info->UNCip || !volume_info->UNC)
2790 goto out;
2791
2792 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2793 volume_info->UNCip,
2794 strlen(volume_info->UNCip),
2795 volume_info->port);
2796 if (!rc)
2797 goto out;
2798
2799 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2800 !match_session(ses, volume_info) ||
2801 !match_tcon(tcon, volume_info->UNC)) {
2802 rc = 0;
2803 goto out;
2804 }
2805
2806 rc = compare_mount_options(sb, mnt_data);
2807out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002808 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002809 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002810 return rc;
2811}
2812
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813int
Steve French96daf2b2011-05-27 04:34:02 +00002814get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
Steve French50c2f752007-07-13 00:33:32 +00002815 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00002816 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817{
2818 char *temp_unc;
2819 int rc = 0;
2820
2821 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00002822 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823
2824 if (pSesInfo->ipc_tid == 0) {
2825 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00002826 strnlen(pSesInfo->serverName,
2827 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 + 1 + 4 /* slash IPC$ */ + 2,
2829 GFP_KERNEL);
2830 if (temp_unc == NULL)
2831 return -ENOMEM;
2832 temp_unc[0] = '\\';
2833 temp_unc[1] = '\\';
2834 strcpy(temp_unc + 2, pSesInfo->serverName);
2835 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2836 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002837 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 kfree(temp_unc);
2839 }
2840 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00002841 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07002842 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00002843 /* BB map targetUNCs to dfs_info3 structures, here or
2844 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845
2846 return rc;
2847}
2848
Jeff Layton09e50d52008-07-23 10:11:19 -04002849#ifdef CONFIG_DEBUG_LOCK_ALLOC
2850static struct lock_class_key cifs_key[2];
2851static struct lock_class_key cifs_slock_key[2];
2852
2853static inline void
2854cifs_reclassify_socket4(struct socket *sock)
2855{
2856 struct sock *sk = sock->sk;
2857 BUG_ON(sock_owned_by_user(sk));
2858 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2859 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2860}
2861
2862static inline void
2863cifs_reclassify_socket6(struct socket *sock)
2864{
2865 struct sock *sk = sock->sk;
2866 BUG_ON(sock_owned_by_user(sk));
2867 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2868 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2869}
2870#else
2871static inline void
2872cifs_reclassify_socket4(struct socket *sock)
2873{
2874}
2875
2876static inline void
2877cifs_reclassify_socket6(struct socket *sock)
2878{
2879}
2880#endif
2881
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002883static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884{
Steve French50c2f752007-07-13 00:33:32 +00002885 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886
Steve French50c2f752007-07-13 00:33:32 +00002887 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 /* mask a nibble at a time and encode */
2889 target[j] = 'A' + (0x0F & (source[i] >> 4));
2890 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002891 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 }
2893
2894}
2895
Ben Greear3eb9a882010-09-01 17:06:02 -07002896static int
2897bind_socket(struct TCP_Server_Info *server)
2898{
2899 int rc = 0;
2900 if (server->srcaddr.ss_family != AF_UNSPEC) {
2901 /* Bind to the specified local IP address */
2902 struct socket *socket = server->ssocket;
2903 rc = socket->ops->bind(socket,
2904 (struct sockaddr *) &server->srcaddr,
2905 sizeof(server->srcaddr));
2906 if (rc < 0) {
2907 struct sockaddr_in *saddr4;
2908 struct sockaddr_in6 *saddr6;
2909 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2910 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2911 if (saddr6->sin6_family == AF_INET6)
2912 cERROR(1, "cifs: "
2913 "Failed to bind to: %pI6c, error: %d\n",
2914 &saddr6->sin6_addr, rc);
2915 else
2916 cERROR(1, "cifs: "
2917 "Failed to bind to: %pI4, error: %d\n",
2918 &saddr4->sin_addr.s_addr, rc);
2919 }
2920 }
2921 return rc;
2922}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923
2924static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002925ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926{
2927 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002928 /*
2929 * some servers require RFC1001 sessinit before sending
2930 * negprot - BB check reconnection in case where second
2931 * sessinit is sent but no second negprot
2932 */
2933 struct rfc1002_session_packet *ses_init_buf;
2934 struct smb_hdr *smb_buf;
2935 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2936 GFP_KERNEL);
2937 if (ses_init_buf) {
2938 ses_init_buf->trailer.session_req.called_len = 32;
2939
2940 if (server->server_RFC1001_name &&
2941 server->server_RFC1001_name[0] != 0)
2942 rfc1002mangle(ses_init_buf->trailer.
2943 session_req.called_name,
2944 server->server_RFC1001_name,
2945 RFC1001_NAME_LEN_WITH_NULL);
2946 else
2947 rfc1002mangle(ses_init_buf->trailer.
2948 session_req.called_name,
2949 DEFAULT_CIFS_CALLED_NAME,
2950 RFC1001_NAME_LEN_WITH_NULL);
2951
2952 ses_init_buf->trailer.session_req.calling_len = 32;
2953
2954 /*
2955 * calling name ends in null (byte 16) from old smb
2956 * convention.
2957 */
2958 if (server->workstation_RFC1001_name &&
2959 server->workstation_RFC1001_name[0] != 0)
2960 rfc1002mangle(ses_init_buf->trailer.
2961 session_req.calling_name,
2962 server->workstation_RFC1001_name,
2963 RFC1001_NAME_LEN_WITH_NULL);
2964 else
2965 rfc1002mangle(ses_init_buf->trailer.
2966 session_req.calling_name,
2967 "LINUX_CIFS_CLNT",
2968 RFC1001_NAME_LEN_WITH_NULL);
2969
2970 ses_init_buf->trailer.session_req.scope1 = 0;
2971 ses_init_buf->trailer.session_req.scope2 = 0;
2972 smb_buf = (struct smb_hdr *)ses_init_buf;
2973
2974 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002975 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002976 rc = smb_send(server, smb_buf, 0x44);
2977 kfree(ses_init_buf);
2978 /*
2979 * RFC1001 layer in at least one server
2980 * requires very short break before negprot
2981 * presumably because not expecting negprot
2982 * to follow so fast. This is a simple
2983 * solution that works without
2984 * complicating the code and causes no
2985 * significant slowing down on mount
2986 * for everyone else
2987 */
2988 usleep_range(1000, 2000);
2989 }
2990 /*
2991 * else the negprot may still work without this
2992 * even though malloc failed
2993 */
2994
2995 return rc;
2996}
2997
2998static int
2999generic_ip_connect(struct TCP_Server_Info *server)
3000{
3001 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00003002 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003003 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003004 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003005 struct sockaddr *saddr;
3006
3007 saddr = (struct sockaddr *) &server->dstaddr;
3008
3009 if (server->dstaddr.ss_family == AF_INET6) {
3010 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3011 slen = sizeof(struct sockaddr_in6);
3012 sfamily = AF_INET6;
3013 } else {
3014 sport = ((struct sockaddr_in *) saddr)->sin_port;
3015 slen = sizeof(struct sockaddr_in);
3016 sfamily = AF_INET;
3017 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003019 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06003020 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3021 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003023 cERROR(1, "Error %d creating socket", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003024 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003027
3028 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003029 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003030 server->ssocket = socket;
3031 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003032 if (sfamily == AF_INET6)
3033 cifs_reclassify_socket6(socket);
3034 else
3035 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 }
3037
Ben Greear3eb9a882010-09-01 17:06:02 -07003038 rc = bind_socket(server);
3039 if (rc < 0)
3040 return rc;
3041
Jeff Laytond5c56052008-12-01 18:42:33 -05003042 /*
3043 * Eventually check for other socket options to change from
3044 * the default. sock_setsockopt not used because it expects
3045 * user space buffer
3046 */
3047 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00003048 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00003049
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003050 /* make the bufsizes depend on wsize/rsize and max requests */
3051 if (server->noautotune) {
3052 if (socket->sk->sk_sndbuf < (200 * 1024))
3053 socket->sk->sk_sndbuf = 200 * 1024;
3054 if (socket->sk->sk_rcvbuf < (140 * 1024))
3055 socket->sk->sk_rcvbuf = 140 * 1024;
3056 }
3057
Steve French6a5fa2362010-01-01 01:28:43 +00003058 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003059 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00003060 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3061 (char *)&val, sizeof(val));
3062 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003063 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00003064 }
3065
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003066 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3067 socket->sk->sk_sndbuf,
3068 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3069
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003070 rc = socket->ops->connect(socket, saddr, slen, 0);
3071 if (rc < 0) {
3072 cFYI(1, "Error %d connecting to server", rc);
3073 sock_release(socket);
3074 server->ssocket = NULL;
3075 return rc;
3076 }
3077
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003078 if (sport == htons(RFC1001_PORT))
3079 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003080
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 return rc;
3082}
3083
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003084static int
3085ip_connect(struct TCP_Server_Info *server)
3086{
Steve French6da97912011-03-13 18:55:55 +00003087 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003088 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3089 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3090
3091 if (server->dstaddr.ss_family == AF_INET6)
3092 sport = &addr6->sin6_port;
3093 else
3094 sport = &addr->sin_port;
3095
3096 if (*sport == 0) {
3097 int rc;
3098
3099 /* try with 445 port at first */
3100 *sport = htons(CIFS_PORT);
3101
3102 rc = generic_ip_connect(server);
3103 if (rc >= 0)
3104 return rc;
3105
3106 /* if it failed, try with 139 port */
3107 *sport = htons(RFC1001_PORT);
3108 }
3109
3110 return generic_ip_connect(server);
3111}
3112
Steve French96daf2b2011-05-27 04:34:02 +00003113void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003114 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003115{
3116 /* if we are reconnecting then should we check to see if
3117 * any requested capabilities changed locally e.g. via
3118 * remount but we can not do much about it here
3119 * if they have (even if we could detect it by the following)
3120 * Perhaps we could add a backpointer to array of sb from tcon
3121 * or if we change to make all sb to same share the same
3122 * sb as NFS - then we only have one backpointer to sb.
3123 * What if we wanted to mount the server share twice once with
3124 * and once without posixacls or posix paths? */
3125 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003126
Steve Frenchc18c8422007-07-18 23:21:09 +00003127 if (vol_info && vol_info->no_linux_ext) {
3128 tcon->fsUnixInfo.Capability = 0;
3129 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003130 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00003131 return;
3132 } else if (vol_info)
3133 tcon->unix_ext = 1; /* Unix Extensions supported */
3134
3135 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003136 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00003137 return;
3138 }
Steve French50c2f752007-07-13 00:33:32 +00003139
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003140 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003141 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French6848b732011-05-26 18:38:54 +00003142 cFYI(1, "unix caps which server supports %lld", cap);
Steve French8af18972007-02-14 04:42:51 +00003143 /* check for reconnect case in which we do not
3144 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003145 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003146 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003147 originally at mount time */
3148 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3149 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003150 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3151 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003152 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00003153 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003154 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003155 cERROR(1, "possible reconnect error");
3156 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003157 }
Steve French8af18972007-02-14 04:42:51 +00003158 }
Steve French50c2f752007-07-13 00:33:32 +00003159
Steve French6848b732011-05-26 18:38:54 +00003160 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3161 cERROR(1, "per-share encryption not supported yet");
3162
Steve French8af18972007-02-14 04:42:51 +00003163 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f82007-06-24 18:30:48 +00003164 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003165 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f82007-06-24 18:30:48 +00003166 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003167 cFYI(1, "negotiated posix acl support");
Al Viro2c6292a2011-06-17 09:05:48 -04003168 if (cifs_sb)
3169 cifs_sb->mnt_cifs_flags |=
3170 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003171 }
3172
Steve French75865f82007-06-24 18:30:48 +00003173 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003174 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f82007-06-24 18:30:48 +00003175 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003176 cFYI(1, "negotiate posix pathnames");
Al Viro2c6292a2011-06-17 09:05:48 -04003177 if (cifs_sb)
3178 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003179 CIFS_MOUNT_POSIX_PATHS;
3180 }
Steve French50c2f752007-07-13 00:33:32 +00003181
Joe Perchesb6b38f72010-04-21 03:50:45 +00003182 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003183#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f82007-06-24 18:30:48 +00003184 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003185 cFYI(1, "FCNTL cap");
Steve French75865f82007-06-24 18:30:48 +00003186 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003187 cFYI(1, "EXTATTR cap");
Steve French75865f82007-06-24 18:30:48 +00003188 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003189 cFYI(1, "POSIX path cap");
Steve French75865f82007-06-24 18:30:48 +00003190 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003191 cFYI(1, "XATTR cap");
Steve French75865f82007-06-24 18:30:48 +00003192 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003193 cFYI(1, "POSIX ACL cap");
Steve French75865f82007-06-24 18:30:48 +00003194 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003195 cFYI(1, "very large read cap");
Steve French75865f82007-06-24 18:30:48 +00003196 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003197 cFYI(1, "very large write cap");
Steve French6848b732011-05-26 18:38:54 +00003198 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3199 cFYI(1, "transport encryption cap");
3200 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3201 cFYI(1, "mandatory transport encryption cap");
Steve French8af18972007-02-14 04:42:51 +00003202#endif /* CIFS_DEBUG2 */
3203 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003204 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003205 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00003206 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00003207 cERROR(1, "Negotiating Unix capabilities "
Steve French5a44b312007-09-20 15:16:24 +00003208 "with the server failed. Consider "
3209 "mounting with the Unix Extensions\n"
3210 "disabled, if problems are found, "
3211 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00003212 "option.");
Steve French5a44b312007-09-20 15:16:24 +00003213
Steve French8af18972007-02-14 04:42:51 +00003214 }
3215 }
3216}
3217
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003218void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3219 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003220{
Jeff Layton2de970f2010-10-06 19:51:12 -04003221 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3222
Al Viro2ced6f62011-06-17 09:20:04 -04003223 spin_lock_init(&cifs_sb->tlink_tree_lock);
3224 cifs_sb->tlink_tree = RB_ROOT;
3225
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003226 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003227 * Temporarily set r/wsize for matching superblock. If we end up using
3228 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003229 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003230 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003231 cifs_sb->wsize = pvolume_info->wsize;
3232
Steve French3b795212008-11-13 19:45:32 +00003233 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3234 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3235 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3236 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Al Viro5206efd2011-07-26 03:22:14 -04003237 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003238 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003239
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303240 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003241 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303242
Steve French3b795212008-11-13 19:45:32 +00003243 if (pvolume_info->noperm)
3244 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3245 if (pvolume_info->setuids)
3246 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3247 if (pvolume_info->server_ino)
3248 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3249 if (pvolume_info->remap)
3250 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3251 if (pvolume_info->no_xattr)
3252 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3253 if (pvolume_info->sfu_emul)
3254 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3255 if (pvolume_info->nobrl)
3256 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003257 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003258 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003259 if (pvolume_info->mand_lock)
3260 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003261 if (pvolume_info->rwpidforward)
3262 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003263 if (pvolume_info->cifs_acl)
3264 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003265 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003266 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003267 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3268 }
3269 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003270 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003271 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3272 }
Steve French3b795212008-11-13 19:45:32 +00003273 if (pvolume_info->override_uid)
3274 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3275 if (pvolume_info->override_gid)
3276 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3277 if (pvolume_info->dynperm)
3278 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303279 if (pvolume_info->fsc)
3280 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003281 if (pvolume_info->multiuser)
3282 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3283 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003284 if (pvolume_info->strict_io)
3285 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003286 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003287 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00003288 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3289 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003290 if (pvolume_info->mfsymlinks) {
3291 if (pvolume_info->sfu_emul) {
3292 cERROR(1, "mount option mfsymlinks ignored if sfu "
3293 "mount option is used");
3294 } else {
3295 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3296 }
3297 }
Steve French3b795212008-11-13 19:45:32 +00003298
3299 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00003300 cERROR(1, "mount option dynperm ignored if cifsacl "
3301 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003302}
3303
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003304/*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003305 * When the server supports very large reads and writes via POSIX extensions,
3306 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3307 * including the RFC1001 length.
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003308 *
3309 * Note that this might make for "interesting" allocation problems during
Jeff Layton1190f6a2011-06-22 17:33:57 -04003310 * writeback however as we have to allocate an array of pointers for the
3311 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003312 *
3313 * For reads, there is a similar problem as we need to allocate an array
3314 * of kvecs to handle the receive, though that should only need to be done
3315 * once.
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003316 */
Jeff Layton1190f6a2011-06-22 17:33:57 -04003317#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003318#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003319
3320/*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003321 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3322 * of 2^17-1 minus the size of the call header. That allows for a read or
3323 * write up to the maximum size described by RFC1002.
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003324 */
Pavel Shilovsky94443f42011-10-07 18:57:45 +04003325#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003326#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003327
3328/*
3329 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3330 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3331 * a single wsize request with a single call.
3332 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003333#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3334
3335/*
Jeff Laytonce91acb2012-01-17 16:08:51 -05003336 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3337 * those values when posix extensions aren't in force. In actuality here, we
3338 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3339 * to be ok with the extra byte even though Windows doesn't send writes that
3340 * are that large.
3341 *
3342 * Citation:
3343 *
3344 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003345 */
3346#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
Jeff Laytonce91acb2012-01-17 16:08:51 -05003347#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003348
3349static unsigned int
Steve French96daf2b2011-05-27 04:34:02 +00003350cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003351{
3352 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3353 struct TCP_Server_Info *server = tcon->ses->server;
Jeff Laytonce91acb2012-01-17 16:08:51 -05003354 unsigned int wsize;
3355
3356 /* start with specified wsize, or default */
3357 if (pvolume_info->wsize)
3358 wsize = pvolume_info->wsize;
3359 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3360 wsize = CIFS_DEFAULT_IOSIZE;
3361 else
3362 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003363
3364 /* can server support 24-bit write sizes? (via UNIX extensions) */
3365 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
Jeff Layton1190f6a2011-06-22 17:33:57 -04003366 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003367
Jeff Layton1190f6a2011-06-22 17:33:57 -04003368 /*
3369 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3370 * Limit it to max buffer offered by the server, minus the size of the
3371 * WRITEX header, not including the 4 byte RFC1001 length.
3372 */
3373 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3374 (!(server->capabilities & CAP_UNIX) &&
3375 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3376 wsize = min_t(unsigned int, wsize,
3377 server->maxBuf - sizeof(WRITE_REQ) + 4);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003378
3379 /* hard limit of CIFS_MAX_WSIZE */
3380 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3381
3382 return wsize;
3383}
3384
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003385static unsigned int
3386cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3387{
3388 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3389 struct TCP_Server_Info *server = tcon->ses->server;
3390 unsigned int rsize, defsize;
3391
3392 /*
3393 * Set default value...
3394 *
3395 * HACK alert! Ancient servers have very small buffers. Even though
3396 * MS-CIFS indicates that servers are only limited by the client's
3397 * bufsize for reads, testing against win98se shows that it throws
3398 * INVALID_PARAMETER errors if you try to request too large a read.
3399 *
3400 * If the server advertises a MaxBufferSize of less than one page,
3401 * assume that it also can't satisfy reads larger than that either.
3402 *
3403 * FIXME: Is there a better heuristic for this?
3404 */
3405 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3406 defsize = CIFS_DEFAULT_IOSIZE;
3407 else if (server->capabilities & CAP_LARGE_READ_X)
3408 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3409 else if (server->maxBuf >= PAGE_CACHE_SIZE)
3410 defsize = CIFSMaxBufSize;
3411 else
3412 defsize = server->maxBuf - sizeof(READ_RSP);
3413
3414 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3415
3416 /*
3417 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3418 * the client's MaxBufferSize.
3419 */
3420 if (!(server->capabilities & CAP_LARGE_READ_X))
3421 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3422
3423 /* hard limit of CIFS_MAX_RSIZE */
3424 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3425
3426 return rsize;
3427}
3428
Igor Mammedove4cce942009-02-10 14:10:26 +03003429static int
Steve French96daf2b2011-05-27 04:34:02 +00003430is_path_accessible(int xid, struct cifs_tcon *tcon,
Igor Mammedove4cce942009-02-10 14:10:26 +03003431 struct cifs_sb_info *cifs_sb, const char *full_path)
3432{
3433 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03003434 FILE_ALL_INFO *pfile_info;
3435
Igor Mammedove4cce942009-02-10 14:10:26 +03003436 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3437 if (pfile_info == NULL)
3438 return -ENOMEM;
3439
3440 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3441 0 /* not legacy */, cifs_sb->local_nls,
3442 cifs_sb->mnt_cifs_flags &
3443 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton221d1d72011-05-17 06:40:30 -04003444
3445 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3446 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3447 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3448 CIFS_MOUNT_MAP_SPECIAL_CHR);
Igor Mammedove4cce942009-02-10 14:10:26 +03003449 kfree(pfile_info);
3450 return rc;
3451}
3452
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003453static void
3454cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003455{
Sean Finneyb9468452011-04-11 13:19:32 +00003456 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003457 kzfree(volume_info->password);
Steve French13589c42011-08-18 04:41:55 +00003458 if (volume_info->UNCip != volume_info->UNC + 2)
3459 kfree(volume_info->UNCip);
Jesper Juhl95c75452011-08-27 18:58:34 +02003460 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003461 kfree(volume_info->domainname);
3462 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003463 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003464}
3465
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003466void
3467cifs_cleanup_volume_info(struct smb_vol *volume_info)
3468{
3469 if (!volume_info)
3470 return;
3471 cleanup_volume_info_contents(volume_info);
3472 kfree(volume_info);
3473}
3474
3475
Steve French2d6d5892009-04-09 00:36:44 +00003476#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003477/* build_path_to_root returns full path to root when
3478 * we do not have an exiting connection (tcon) */
3479static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003480build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003481 const struct cifs_sb_info *cifs_sb)
3482{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003483 char *full_path, *pos;
3484 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3485 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003486
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003487 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003488 if (full_path == NULL)
3489 return ERR_PTR(-ENOMEM);
3490
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003491 strncpy(full_path, vol->UNC, unc_len);
3492 pos = full_path + unc_len;
3493
3494 if (pplen) {
3495 strncpy(pos, vol->prepath, pplen);
3496 pos += pplen;
3497 }
3498
3499 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003500 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003501 cFYI(1, "%s: full_path=%s", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003502 return full_path;
3503}
Sean Finneydd613942011-04-11 13:19:30 +00003504
3505/*
3506 * Perform a dfs referral query for a share and (optionally) prefix
3507 *
Sean Finney046462a2011-04-11 13:19:33 +00003508 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3509 * to a string containing updated options for the submount. Otherwise it
3510 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003511 *
3512 * Returns the rc from get_dfs_path to the caller, which can be used to
3513 * determine whether there were referrals.
3514 */
3515static int
Steve French96daf2b2011-05-27 04:34:02 +00003516expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
Sean Finneydd613942011-04-11 13:19:30 +00003517 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003518 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003519{
3520 int rc;
3521 unsigned int num_referrals = 0;
3522 struct dfs_info3_param *referrals = NULL;
3523 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3524
3525 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3526 if (IS_ERR(full_path))
3527 return PTR_ERR(full_path);
3528
3529 /* For DFS paths, skip the first '\' of the UNC */
3530 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3531
3532 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3533 &num_referrals, &referrals,
3534 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3535
3536 if (!rc && num_referrals > 0) {
3537 char *fake_devname = NULL;
3538
3539 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3540 full_path + 1, referrals,
3541 &fake_devname);
3542
3543 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003544
Sean Finneydd613942011-04-11 13:19:30 +00003545 if (IS_ERR(mdata)) {
3546 rc = PTR_ERR(mdata);
3547 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003548 } else {
3549 cleanup_volume_info_contents(volume_info);
3550 memset(volume_info, '\0', sizeof(*volume_info));
3551 rc = cifs_setup_volume_info(volume_info, mdata,
3552 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003553 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003554 kfree(fake_devname);
3555 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003556 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003557 }
3558 kfree(full_path);
3559 return rc;
3560}
Steve French2d6d5892009-04-09 00:36:44 +00003561#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003562
Jeff Layton04db79b2011-07-06 08:10:38 -04003563static int
3564cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3565 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003567 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003568
Jeff Layton04db79b2011-07-06 08:10:38 -04003569 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3570 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571
Jeff Layton7586b762008-12-01 18:41:49 -05003572 if (volume_info->nullauth) {
Jeff Layton04febab2012-01-17 16:09:15 -05003573 cFYI(1, "Anonymous login");
3574 kfree(volume_info->username);
3575 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003576 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003578 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08003580 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00003581 /* In userspace mount helper we can get user name from alternate
3582 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003583 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584 }
3585
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003587 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003588 /* load_nls_default cannot return null */
3589 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003591 volume_info->local_nls = load_nls(volume_info->iocharset);
3592 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003593 cERROR(1, "CIFS mount error: iocharset %s not found",
3594 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003595 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 }
3597 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003598
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003599 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003600}
3601
3602struct smb_vol *
3603cifs_get_volume_info(char *mount_data, const char *devname)
3604{
3605 int rc;
3606 struct smb_vol *volume_info;
3607
3608 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3609 if (!volume_info)
3610 return ERR_PTR(-ENOMEM);
3611
3612 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3613 if (rc) {
3614 cifs_cleanup_volume_info(volume_info);
3615 volume_info = ERR_PTR(rc);
3616 }
3617
3618 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003619}
3620
3621int
Al Viro2c6292a2011-06-17 09:05:48 -04003622cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003623{
Jeff Layton1daaae82012-03-21 06:30:40 -04003624 int rc;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003625 int xid;
Steve French96daf2b2011-05-27 04:34:02 +00003626 struct cifs_ses *pSesInfo;
3627 struct cifs_tcon *tcon;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003628 struct TCP_Server_Info *srvTcp;
3629 char *full_path;
3630 struct tcon_link *tlink;
3631#ifdef CONFIG_CIFS_DFS_UPCALL
3632 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003633#endif
Al Virodd854462011-06-17 08:24:42 -04003634
3635 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3636 if (rc)
3637 return rc;
3638
Jeff Layton20547492011-07-09 12:21:07 -04003639#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003640try_mount_again:
3641 /* cleanup activities if we're chasing a referral */
3642 if (referral_walks_count) {
3643 if (tcon)
3644 cifs_put_tcon(tcon);
3645 else if (pSesInfo)
3646 cifs_put_smb_ses(pSesInfo);
3647
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003648 FreeXid(xid);
3649 }
3650#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003651 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003652 tcon = NULL;
3653 pSesInfo = NULL;
3654 srvTcp = NULL;
3655 full_path = NULL;
3656 tlink = NULL;
3657
3658 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003659
Jeff Layton63c038c2008-12-01 18:41:46 -05003660 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05003661 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05003662 if (IS_ERR(srvTcp)) {
3663 rc = PTR_ERR(srvTcp);
Al Virodd854462011-06-17 08:24:42 -04003664 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003665 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666 }
3667
Jeff Layton36988c72010-04-24 07:57:43 -04003668 /* get a reference to a SMB session */
3669 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3670 if (IS_ERR(pSesInfo)) {
3671 rc = PTR_ERR(pSesInfo);
3672 pSesInfo = NULL;
3673 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003674 }
Steve French50c2f752007-07-13 00:33:32 +00003675
Jeff Laytond00c28d2010-04-24 07:57:44 -04003676 /* search for existing tcon to this server share */
3677 tcon = cifs_get_tcon(pSesInfo, volume_info);
3678 if (IS_ERR(tcon)) {
3679 rc = PTR_ERR(tcon);
3680 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003681 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003682 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003683
Steve French6848b732011-05-26 18:38:54 +00003684 /* tell server which Unix caps we support */
3685 if (tcon->ses->capabilities & CAP_UNIX) {
3686 /* reset of caps checks mount to see if unix extensions
3687 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003688 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003689 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3690 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3691 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3692 rc = -EACCES;
3693 goto mount_fail_check;
3694 }
3695 } else
3696 tcon->unix_ext = 0; /* server does not support them */
3697
Steve Frenchd82c2df2008-11-15 00:07:26 +00003698 /* do not care if following two calls succeed - informational */
3699 if (!tcon->ipc) {
3700 CIFSSMBQFSDeviceInfo(xid, tcon);
3701 CIFSSMBQFSAttributeInfo(xid, tcon);
3702 }
3703
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003704 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003705 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003706
Jeff Layton66bfaad2011-10-19 15:30:35 -04003707 /* tune readahead according to rsize */
Jeff Layton8f714652012-05-01 17:41:49 -04003708 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003709
Igor Mammedove4cce942009-02-10 14:10:26 +03003710remote_path_check:
3711#ifdef CONFIG_CIFS_DFS_UPCALL
3712 /*
3713 * Perform an unconditional check for whether there are DFS
3714 * referrals for this path without prefix, to provide support
3715 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003716 * with PATH_NOT_COVERED to requests that include the prefix.
3717 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003718 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003719 if (referral_walks_count == 0) {
3720 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3721 cifs_sb, false);
3722 if (!refrc) {
3723 referral_walks_count++;
3724 goto try_mount_again;
3725 }
3726 }
3727#endif
3728
Steve Frenchf87d39d2011-05-27 03:50:55 +00003729 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 if (!rc && tcon) {
3731 /* build_path_to_root works only when we have a valid tcon */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003732 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Steve French7c7b25b2006-06-01 19:20:10 +00003733 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003734 rc = -ENOMEM;
3735 goto mount_fail_check;
3736 }
3737 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3738 if (rc != 0 && rc != -EREMOTE) {
3739 kfree(full_path);
3740 goto mount_fail_check;
3741 }
3742 kfree(full_path);
3743 }
3744
3745 /* get referral if needed */
3746 if (rc == -EREMOTE) {
3747#ifdef CONFIG_CIFS_DFS_UPCALL
3748 if (referral_walks_count > MAX_NESTED_LINKS) {
3749 /*
Steve Frencheeac8042006-01-13 21:34:58 -08003750 * BB: when we implement proper loop detection,
Steve French4523cc32007-04-30 20:13:06 +00003751 * we will remove this check. But now we need it
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 * to prevent an indefinite loop if 'DFS tree' is
3753 * misconfigured (i.e. has loops).
3754 */
3755 rc = -ELOOP;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003756 goto mount_fail_check;
3757 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003758
Sean Finneydd613942011-04-11 13:19:30 +00003759 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003760 true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003761
Sean Finneydd613942011-04-11 13:19:30 +00003762 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003763 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003764 goto try_mount_again;
3765 }
Sean Finneydd613942011-04-11 13:19:30 +00003766 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003767#else /* No DFS support, return error on mount */
3768 rc = -EOPNOTSUPP;
3769#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003770 }
3771
Jeff Layton9d002df2010-10-06 19:51:11 -04003772 if (rc)
3773 goto mount_fail_check;
3774
3775 /* now, hang the tcon off of the superblock */
3776 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3777 if (tlink == NULL) {
3778 rc = -ENOMEM;
3779 goto mount_fail_check;
3780 }
3781
Jeff Laytonb647c352010-10-28 11:16:44 -04003782 tlink->tl_uid = pSesInfo->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003783 tlink->tl_tcon = tcon;
3784 tlink->tl_time = jiffies;
3785 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3786 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3787
Jeff Layton413e6612010-10-28 13:33:38 -04003788 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003789 spin_lock(&cifs_sb->tlink_tree_lock);
3790 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3791 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003792
Jeff Laytonda472fc2012-03-23 14:40:53 -04003793 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003794 TLINK_IDLE_EXPIRE);
3795
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003796mount_fail_check:
3797 /* on error free sesinfo and tcon struct if needed */
3798 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003799 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003800 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003801 if (tcon)
3802 cifs_put_tcon(tcon);
3803 else if (pSesInfo)
3804 cifs_put_smb_ses(pSesInfo);
3805 else
3806 cifs_put_tcp_session(srvTcp);
Al Virodd854462011-06-17 08:24:42 -04003807 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003808 }
3809
Linus Torvalds1da177e2005-04-16 15:20:36 -07003810out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811 FreeXid(xid);
3812 return rc;
3813}
3814
Jeff Layton8d1bca32011-06-11 21:17:10 -04003815/*
3816 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3817 * pointer may be NULL.
3818 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819int
Steve French96daf2b2011-05-27 04:34:02 +00003820CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3821 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003822 const struct nls_table *nls_codepage)
3823{
3824 struct smb_hdr *smb_buffer;
3825 struct smb_hdr *smb_buffer_response;
3826 TCONX_REQ *pSMB;
3827 TCONX_RSP *pSMBr;
3828 unsigned char *bcc_ptr;
3829 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003830 int length;
3831 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003832
3833 if (ses == NULL)
3834 return -EIO;
3835
3836 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003837 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003839
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840 smb_buffer_response = smb_buffer;
3841
3842 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3843 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003844
3845 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846 smb_buffer->Uid = ses->Suid;
3847 pSMB = (TCONX_REQ *) smb_buffer;
3848 pSMBr = (TCONX_RSP *) smb_buffer_response;
3849
3850 pSMB->AndXCommand = 0xFF;
3851 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003852 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003853 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003854 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003855 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003856 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003857 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003858 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003859 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003860 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3861 specified as required (when that support is added to
3862 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003863 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003864 by Samba (not sure whether other servers allow
3865 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003866#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003867 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003868 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003869 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003870 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003871 SECMODE_PW_ENCRYPT ? true : false,
3872 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003873 else
3874#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003875 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003876 bcc_ptr, nls_codepage);
Steve Frencheeac8042006-01-13 21:34:58 -08003877
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003878 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003879 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003880 /* must align unicode strings */
3881 *bcc_ptr = 0; /* null byte password */
3882 bcc_ptr++;
3883 }
Steve Frencheeac8042006-01-13 21:34:58 -08003884 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003885
Steve French96daf2b2011-05-27 04:34:02 +00003886 if (ses->server->sec_mode &
Steve Frencha878fb22006-05-30 18:04:19 +00003887 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003888 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3889
3890 if (ses->capabilities & CAP_STATUS32) {
3891 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3892 }
3893 if (ses->capabilities & CAP_DFS) {
3894 smb_buffer->Flags2 |= SMBFLG2_DFS;
3895 }
3896 if (ses->capabilities & CAP_UNICODE) {
3897 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3898 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003899 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003900 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003901 (/* server len*/ + 256 /* share len */), nls_codepage);
3902 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003903 bcc_ptr += 2; /* skip trailing null */
3904 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003905 strcpy(bcc_ptr, tree);
3906 bcc_ptr += strlen(tree) + 1;
3907 }
3908 strcpy(bcc_ptr, "?????");
3909 bcc_ptr += strlen("?????");
3910 bcc_ptr += 1;
3911 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003912 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3913 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003914 pSMB->ByteCount = cpu_to_le16(count);
3915
Steve French133672e2007-11-13 22:41:37 +00003916 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003917 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003918
Linus Torvalds1da177e2005-04-16 15:20:36 -07003919 /* above now done in SendReceive */
3920 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003921 bool is_unicode;
3922
Linus Torvalds1da177e2005-04-16 15:20:36 -07003923 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003924 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003925 tcon->tid = smb_buffer_response->Tid;
3926 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003927 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003928 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003929 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3930 is_unicode = true;
3931 else
3932 is_unicode = false;
3933
Jeff Laytoncc20c032009-04-30 07:16:21 -04003934
Steve French50c2f752007-07-13 00:33:32 +00003935 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003936 if (length == 3) {
3937 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3938 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003939 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003940 tcon->ipc = 1;
3941 }
3942 } else if (length == 2) {
3943 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3944 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003945 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003946 }
3947 }
Steve French50c2f752007-07-13 00:33:32 +00003948 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003949 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003950 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003951
3952 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003953 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003954 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003955 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003956 nls_codepage);
3957
Joe Perchesb6b38f72010-04-21 03:50:45 +00003958 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003959
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003960 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003961 (smb_buffer_response->WordCount == 7))
3962 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003963 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3964 else
3965 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003966 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003967 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003968 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 ses->ipc_tid = smb_buffer_response->Tid;
3970 }
3971
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003972 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003973 return rc;
3974}
3975
Al Viro2a9b9952011-06-17 09:27:16 -04003976void
3977cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978{
Jeff Laytonb647c352010-10-28 11:16:44 -04003979 struct rb_root *root = &cifs_sb->tlink_tree;
3980 struct rb_node *node;
3981 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003982
Jeff Layton2de970f2010-10-06 19:51:12 -04003983 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3984
Jeff Laytonb647c352010-10-28 11:16:44 -04003985 spin_lock(&cifs_sb->tlink_tree_lock);
3986 while ((node = rb_first(root))) {
3987 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3988 cifs_get_tlink(tlink);
3989 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3990 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003991
Jeff Laytonb647c352010-10-28 11:16:44 -04003992 spin_unlock(&cifs_sb->tlink_tree_lock);
3993 cifs_put_tlink(tlink);
3994 spin_lock(&cifs_sb->tlink_tree_lock);
3995 }
3996 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003997
Al Virodd854462011-06-17 08:24:42 -04003998 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003999 kfree(cifs_sb->mountdata);
4000 unload_nls(cifs_sb->local_nls);
4001 kfree(cifs_sb);
Steve French50c2f752007-07-13 00:33:32 +00004002}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004003
Steve French96daf2b2011-05-27 04:34:02 +00004004int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004005{
4006 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04004007 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004008
Jeff Layton198b5682010-04-24 07:57:48 -04004009 /* only send once per connect */
4010 if (server->maxBuf != 0)
4011 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004012
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04004013 cifs_set_credits(server, 1);
Jeff Layton198b5682010-04-24 07:57:48 -04004014 rc = CIFSSMBNegotiate(xid, ses);
4015 if (rc == -EAGAIN) {
4016 /* retry only once on 1st time connection */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04004017 cifs_set_credits(server, 1);
Jeff Layton198b5682010-04-24 07:57:48 -04004018 rc = CIFSSMBNegotiate(xid, ses);
4019 if (rc == -EAGAIN)
4020 rc = -EHOSTDOWN;
4021 }
4022 if (rc == 0) {
4023 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04004024 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04004025 server->tcpStatus = CifsGood;
4026 else
4027 rc = -EHOSTDOWN;
4028 spin_unlock(&GlobalMid_Lock);
4029
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030 }
Steve French26b994f2008-08-06 05:11:33 +00004031
Jeff Layton198b5682010-04-24 07:57:48 -04004032 return rc;
4033}
Steve French26b994f2008-08-06 05:11:33 +00004034
Jeff Layton198b5682010-04-24 07:57:48 -04004035
Steve French96daf2b2011-05-27 04:34:02 +00004036int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
Jeff Layton198b5682010-04-24 07:57:48 -04004037 struct nls_table *nls_info)
4038{
4039 int rc = 0;
4040 struct TCP_Server_Info *server = ses->server;
4041
4042 ses->flags = 0;
4043 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00004044 if (linuxExtEnabled == 0)
Jeff Layton198b5682010-04-24 07:57:48 -04004045 ses->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00004046
Joe Perchesb6b38f72010-04-21 03:50:45 +00004047 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Steve French96daf2b2011-05-27 04:34:02 +00004048 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04004049
Jeff Layton198b5682010-04-24 07:57:48 -04004050 rc = CIFS_SessSetup(xid, ses, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00004051 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004052 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00004053 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05004054 mutex_lock(&ses->server->srv_mutex);
4055 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05004056 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05004057 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05004058 server->sequence_number = 0x2;
4059 server->session_estab = true;
4060 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05004061 }
4062 mutex_unlock(&server->srv_mutex);
4063
Joe Perchesb6b38f72010-04-21 03:50:45 +00004064 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00004065 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04004066 ses->status = CifsGood;
4067 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00004068 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00004069 }
4070
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05004071 kfree(ses->auth_key.response);
4072 ses->auth_key.response = NULL;
4073 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05004074 kfree(ses->ntlmssp);
4075 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05004076
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077 return rc;
4078}
4079
Jeff Layton8a8798a2012-01-17 16:09:15 -05004080static int
4081cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4082{
4083 switch (ses->server->secType) {
4084 case Kerberos:
4085 vol->secFlg = CIFSSEC_MUST_KRB5;
4086 return 0;
4087 case NTLMv2:
4088 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4089 break;
4090 case NTLM:
4091 vol->secFlg = CIFSSEC_MUST_NTLM;
4092 break;
4093 case RawNTLMSSP:
4094 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4095 break;
4096 case LANMAN:
4097 vol->secFlg = CIFSSEC_MUST_LANMAN;
4098 break;
4099 }
4100
4101 return cifs_set_cifscreds(vol, ses);
4102}
4103
Steve French96daf2b2011-05-27 04:34:02 +00004104static struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04004105cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4106{
Jeff Layton8a8798a2012-01-17 16:09:15 -05004107 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00004108 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4109 struct cifs_ses *ses;
4110 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04004111 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04004112
4113 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03004114 if (vol_info == NULL)
4115 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04004116
Jeff Layton9d002df2010-10-06 19:51:11 -04004117 vol_info->local_nls = cifs_sb->local_nls;
4118 vol_info->linux_uid = fsuid;
4119 vol_info->cred_uid = fsuid;
4120 vol_info->UNC = master_tcon->treeName;
4121 vol_info->retry = master_tcon->retry;
4122 vol_info->nocase = master_tcon->nocase;
4123 vol_info->local_lease = master_tcon->local_lease;
4124 vol_info->no_linux_ext = !master_tcon->unix_ext;
4125
Jeff Layton8a8798a2012-01-17 16:09:15 -05004126 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4127 if (rc) {
4128 tcon = ERR_PTR(rc);
4129 goto out;
4130 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004131
4132 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304133 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004134 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304135 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004136
4137 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4138 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00004139 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04004140 cifs_put_tcp_session(master_tcon->ses->server);
4141 goto out;
4142 }
4143
4144 tcon = cifs_get_tcon(ses, vol_info);
4145 if (IS_ERR(tcon)) {
4146 cifs_put_smb_ses(ses);
4147 goto out;
4148 }
4149
4150 if (ses->capabilities & CAP_UNIX)
4151 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4152out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05004153 kfree(vol_info->username);
4154 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04004155 kfree(vol_info);
4156
4157 return tcon;
4158}
4159
Steve French96daf2b2011-05-27 04:34:02 +00004160struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04004161cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4162{
4163 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4164}
4165
4166static int
4167cifs_sb_tcon_pending_wait(void *unused)
4168{
4169 schedule();
4170 return signal_pending(current) ? -ERESTARTSYS : 0;
4171}
4172
Jeff Laytonb647c352010-10-28 11:16:44 -04004173/* find and return a tlink with given uid */
4174static struct tcon_link *
4175tlink_rb_search(struct rb_root *root, uid_t uid)
4176{
4177 struct rb_node *node = root->rb_node;
4178 struct tcon_link *tlink;
4179
4180 while (node) {
4181 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4182
4183 if (tlink->tl_uid > uid)
4184 node = node->rb_left;
4185 else if (tlink->tl_uid < uid)
4186 node = node->rb_right;
4187 else
4188 return tlink;
4189 }
4190 return NULL;
4191}
4192
4193/* insert a tcon_link into the tree */
4194static void
4195tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4196{
4197 struct rb_node **new = &(root->rb_node), *parent = NULL;
4198 struct tcon_link *tlink;
4199
4200 while (*new) {
4201 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4202 parent = *new;
4203
4204 if (tlink->tl_uid > new_tlink->tl_uid)
4205 new = &((*new)->rb_left);
4206 else
4207 new = &((*new)->rb_right);
4208 }
4209
4210 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4211 rb_insert_color(&new_tlink->tl_rbnode, root);
4212}
4213
Jeff Layton9d002df2010-10-06 19:51:11 -04004214/*
4215 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4216 * current task.
4217 *
4218 * If the superblock doesn't refer to a multiuser mount, then just return
4219 * the master tcon for the mount.
4220 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05304221 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04004222 * exists, then check to see if it's pending construction. If it is then wait
4223 * for construction to complete. Once it's no longer pending, check to see if
4224 * it failed and either return an error or retry construction, depending on
4225 * the timeout.
4226 *
4227 * If one doesn't exist then insert a new tcon_link struct into the tree and
4228 * try to construct a new one.
4229 */
4230struct tcon_link *
4231cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4232{
4233 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04004234 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004235 struct tcon_link *tlink, *newtlink;
4236
4237 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4238 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4239
4240 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004241 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004242 if (tlink)
4243 cifs_get_tlink(tlink);
4244 spin_unlock(&cifs_sb->tlink_tree_lock);
4245
4246 if (tlink == NULL) {
4247 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4248 if (newtlink == NULL)
4249 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004250 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004251 newtlink->tl_tcon = ERR_PTR(-EACCES);
4252 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4253 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4254 cifs_get_tlink(newtlink);
4255
Jeff Layton9d002df2010-10-06 19:51:11 -04004256 spin_lock(&cifs_sb->tlink_tree_lock);
4257 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004258 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004259 if (tlink) {
4260 cifs_get_tlink(tlink);
4261 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004262 kfree(newtlink);
4263 goto wait_for_construction;
4264 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004265 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004266 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4267 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004268 } else {
4269wait_for_construction:
4270 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4271 cifs_sb_tcon_pending_wait,
4272 TASK_INTERRUPTIBLE);
4273 if (ret) {
4274 cifs_put_tlink(tlink);
4275 return ERR_PTR(ret);
4276 }
4277
4278 /* if it's good, return it */
4279 if (!IS_ERR(tlink->tl_tcon))
4280 return tlink;
4281
4282 /* return error if we tried this already recently */
4283 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4284 cifs_put_tlink(tlink);
4285 return ERR_PTR(-EACCES);
4286 }
4287
4288 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4289 goto wait_for_construction;
4290 }
4291
4292 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4293 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4294 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4295
4296 if (IS_ERR(tlink->tl_tcon)) {
4297 cifs_put_tlink(tlink);
4298 return ERR_PTR(-EACCES);
4299 }
4300
4301 return tlink;
4302}
Jeff Layton2de970f2010-10-06 19:51:12 -04004303
4304/*
4305 * periodic workqueue job that scans tcon_tree for a superblock and closes
4306 * out tcons.
4307 */
4308static void
4309cifs_prune_tlinks(struct work_struct *work)
4310{
4311 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4312 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004313 struct rb_root *root = &cifs_sb->tlink_tree;
4314 struct rb_node *node = rb_first(root);
4315 struct rb_node *tmp;
4316 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004317
Jeff Laytonb647c352010-10-28 11:16:44 -04004318 /*
4319 * Because we drop the spinlock in the loop in order to put the tlink
4320 * it's not guarded against removal of links from the tree. The only
4321 * places that remove entries from the tree are this function and
4322 * umounts. Because this function is non-reentrant and is canceled
4323 * before umount can proceed, this is safe.
4324 */
4325 spin_lock(&cifs_sb->tlink_tree_lock);
4326 node = rb_first(root);
4327 while (node != NULL) {
4328 tmp = node;
4329 node = rb_next(tmp);
4330 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4331
4332 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4333 atomic_read(&tlink->tl_count) != 0 ||
4334 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4335 continue;
4336
4337 cifs_get_tlink(tlink);
4338 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4339 rb_erase(tmp, root);
4340
Jeff Layton2de970f2010-10-06 19:51:12 -04004341 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004342 cifs_put_tlink(tlink);
4343 spin_lock(&cifs_sb->tlink_tree_lock);
4344 }
4345 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004346
Jeff Laytonda472fc2012-03-23 14:40:53 -04004347 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004348 TLINK_IDLE_EXPIRE);
4349}