blob: 1067473b5ed11dbd63951f10416476208c4881dc [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>
Steve French0e2beda2009-01-30 21:24:41 +000040#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "cifspdu.h"
42#include "cifsglob.h"
43#include "cifsproto.h"
44#include "cifs_unicode.h"
45#include "cifs_debug.h"
46#include "cifs_fs_sb.h"
47#include "ntlmssp.h"
48#include "nterr.h"
49#include "rfc1002pdu.h"
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +053050#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52#define CIFS_PORT 445
53#define RFC1001_PORT 139
54
Jeff Laytonc74093b2011-01-11 07:24:23 -050055/* SMB echo "timeout" -- FIXME: tunable? */
56#define SMB_ECHO_INTERVAL (60 * HZ)
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058extern mempool_t *cifs_req_poolp;
59
60struct smb_vol {
61 char *username;
62 char *password;
63 char *domainname;
64 char *UNC;
65 char *UNCip;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 char *iocharset; /* local code page for mapping to and from Unicode */
Jeff Layton1397f2e2011-01-07 11:30:28 -050067 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
68 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
Jeff Layton3e4b3e12010-07-19 18:00:17 -040069 uid_t cred_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 uid_t linux_uid;
71 gid_t linux_gid;
72 mode_t file_mode;
73 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000074 unsigned secFlg;
Steve French4b18f2a2008-04-29 00:06:05 +000075 bool retry:1;
76 bool intr:1;
77 bool setuids:1;
78 bool override_uid:1;
79 bool override_gid:1;
Jeff Laytond0a9c072008-05-12 22:23:49 +000080 bool dynperm:1;
Steve French4b18f2a2008-04-29 00:06:05 +000081 bool noperm:1;
82 bool no_psx_acl:1; /* set if posix acl support should be disabled */
83 bool cifs_acl:1;
84 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
85 bool server_ino:1; /* use inode numbers from server ie UniqueId */
86 bool direct_io:1;
Pavel Shilovskyd39454f2011-01-24 14:16:35 -050087 bool strict_io:1; /* strict cache behavior */
Steve French95b1cb92008-05-15 16:44:38 +000088 bool remap:1; /* set to remap seven reserved chars in filenames */
89 bool posix_paths:1; /* unset to not ask for posix pathnames. */
Steve French4b18f2a2008-04-29 00:06:05 +000090 bool no_linux_ext:1;
91 bool sfu_emul:1;
Steve French95b1cb92008-05-15 16:44:38 +000092 bool nullauth:1; /* attempt to authenticate with null user */
93 bool nocase:1; /* request case insensitive filenames */
94 bool nobrl:1; /* disable sending byte range locks to srv */
Steve French13a6e422008-12-02 17:24:33 +000095 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
Steve French95b1cb92008-05-15 16:44:38 +000096 bool seal:1; /* request transport encryption on share */
Steve French84210e92008-10-23 04:42:37 +000097 bool nodfs:1; /* Do not request DFS, even if available */
98 bool local_lease:1; /* check leases only on local system, not remote */
Steve Frenchedf1ae42008-10-29 00:47:57 +000099 bool noblocksnd:1;
100 bool noautotune:1;
Steve Frenchbe652442009-02-23 15:21:59 +0000101 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
Suresh Jayaramanfa1df752010-07-05 18:13:36 +0530102 bool fsc:1; /* enable fscache */
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200103 bool mfsymlinks:1; /* use Minshall+French Symlinks */
Jeff Layton0eb8a132010-10-06 19:51:12 -0400104 bool multiuser:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 unsigned int rsize;
106 unsigned int wsize;
Steve French6a5fa2362010-01-01 01:28:43 +0000107 bool sockopt_tcp_nodelay:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 unsigned short int port;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530109 unsigned long actimeo; /* attribute cache timeout (jiffies) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000110 char *prepath;
Ben Greear3eb9a882010-09-01 17:06:02 -0700111 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
Jeff Laytona5fc4ce2010-04-24 07:57:42 -0400112 struct nls_table *local_nls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113};
114
Jeff Layton2de970f2010-10-06 19:51:12 -0400115/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -0400116#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -0400117#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -0400118
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300119static int ip_connect(struct TCP_Server_Info *server);
120static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400121static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400122static void cifs_prune_tlinks(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Jeff Laytond5c56052008-12-01 18:42:33 -0500124/*
125 * cifs tcp session reconnection
126 *
127 * mark tcp session as reconnecting so temporarily locked
128 * mark all smb sessions as reconnecting for tcp session
129 * reconnect tcp session
130 * wake up waiters on reconnection? - (not needed currently)
131 */
Steve French2cd646a2006-09-28 19:43:08 +0000132static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133cifs_reconnect(struct TCP_Server_Info *server)
134{
135 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500136 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct cifsSesInfo *ses;
138 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000139 struct mid_q_entry *mid_entry;
Steve French50c2f752007-07-13 00:33:32 +0000140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000142 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000143 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 next time through the loop */
145 spin_unlock(&GlobalMid_Lock);
146 return rc;
147 } else
148 server->tcpStatus = CifsNeedReconnect;
149 spin_unlock(&GlobalMid_Lock);
150 server->maxBuf = 0;
151
Joe Perchesb6b38f72010-04-21 03:50:45 +0000152 cFYI(1, "Reconnecting tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /* before reconnecting the tcp session, mark the smb session (uid)
155 and the tid bad so they are not used until reconnected */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500156 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530157 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500158 list_for_each(tmp, &server->smb_ses_list) {
159 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
160 ses->need_reconnect = true;
161 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500162 list_for_each(tmp2, &ses->tcon_list) {
163 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
164 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530167 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 /* do not want to be sending data on a socket we are freeing */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500170 cFYI(1, "%s: tearing down socket", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500171 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000172 if (server->ssocket) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000173 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
174 server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800175 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000176 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000177 server->ssocket->state,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000178 server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 sock_release(server->ssocket);
180 server->ssocket = NULL;
181 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500182 server->sequence_number = 0;
183 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500184 kfree(server->session_key.response);
185 server->session_key.response = NULL;
186 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000187 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500188 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500190 /* mark submitted MIDs for retry and issue callback */
191 cFYI(1, "%s: issuing mid callbacks", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500193 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
194 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
195 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
Steve Frenchad8b15f2008-08-08 21:10:16 +0000196 mid_entry->midState = MID_RETRY_NEEDED;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500197 list_del_init(&mid_entry->qhead);
198 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 }
200 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Steve Frenchfd88ce92011-04-12 01:01:14 +0000202 while (server->tcpStatus == CifsNeedReconnect) {
Steve French6c3d8902006-07-31 22:46:20 +0000203 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300204
205 /* we should try only the port we connected to before */
206 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000207 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000208 cFYI(1, "reconnect error %d", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700209 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 } else {
211 atomic_inc(&tcpSesReconnectCount);
212 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000213 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000214 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000215 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 }
217 }
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 return rc;
220}
221
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000222/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700223 return codes:
224 0 not a transact2, or all data present
225 >0 transact2 with that much data missing
226 -EINVAL = invalid transact2
227
228 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000229static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700230{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000231 struct smb_t2_rsp *pSMBt;
Steve Frenche4eb2952005-04-28 22:41:09 -0700232 int remaining;
Jeff Layton26ec2542011-01-20 13:36:51 -0500233 __u16 total_data_size, data_in_this_rsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700234
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000235 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700236 return 0;
237
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000238 /* check for plausible wct, bcc and t2 data and parm sizes */
239 /* check for parm and data offset going beyond end of smb */
240 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000241 cFYI(1, "invalid transact2 word count");
Steve Frenche4eb2952005-04-28 22:41:09 -0700242 return -EINVAL;
243 }
244
245 pSMBt = (struct smb_t2_rsp *)pSMB;
246
Jeff Layton26ec2542011-01-20 13:36:51 -0500247 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
248 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700249
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400250 if (total_data_size == data_in_this_rsp)
Steve Frenche4eb2952005-04-28 22:41:09 -0700251 return 0;
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400252 else if (total_data_size < data_in_this_rsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000253 cFYI(1, "total data %d smaller than data in frame %d",
254 total_data_size, data_in_this_rsp);
Steve Frenche4eb2952005-04-28 22:41:09 -0700255 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700256 }
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400257
258 remaining = total_data_size - data_in_this_rsp;
259
260 cFYI(1, "missing %d bytes from transact2, check next response",
261 remaining);
262 if (total_data_size > maxBufSize) {
263 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
264 total_data_size, maxBufSize);
265 return -EINVAL;
266 }
267 return remaining;
Steve Frenche4eb2952005-04-28 22:41:09 -0700268}
269
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000270static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700271{
272 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
273 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000274 char *data_area_of_target;
275 char *data_area_of_buf2;
Jeff Layton26ec2542011-01-20 13:36:51 -0500276 int remaining;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400277 unsigned int byte_count, total_in_buf;
278 __u16 total_data_size, total_in_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700279
Jeff Layton26ec2542011-01-20 13:36:51 -0500280 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700281
Jeff Layton26ec2542011-01-20 13:36:51 -0500282 if (total_data_size !=
283 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000284 cFYI(1, "total data size of primary and secondary t2 differ");
Steve Frenche4eb2952005-04-28 22:41:09 -0700285
Jeff Layton26ec2542011-01-20 13:36:51 -0500286 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700287
288 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000289
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000290 if (remaining < 0)
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400291 return -EPROTO;
Steve Frenche4eb2952005-04-28 22:41:09 -0700292
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000293 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700294 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000295
Jeff Layton26ec2542011-01-20 13:36:51 -0500296 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000297 if (remaining < total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000298 cFYI(1, "transact2 2nd response contains too much data");
Steve Frenche4eb2952005-04-28 22:41:09 -0700299 }
300
301 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000302 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Jeff Layton26ec2542011-01-20 13:36:51 -0500303 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700304 /* validate target area */
305
Jeff Layton26ec2542011-01-20 13:36:51 -0500306 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
307 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700308
309 data_area_of_target += total_in_buf;
310
311 /* copy second buffer into end of first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700312 total_in_buf += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400313 /* is the result too big for the field? */
314 if (total_in_buf > USHRT_MAX)
315 return -EPROTO;
Jeff Layton26ec2542011-01-20 13:36:51 -0500316 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400317
318 /* fix up the BCC */
Jeff Layton820a8032011-05-04 08:05:26 -0400319 byte_count = get_bcc(pTargetSMB);
Steve Frenche4eb2952005-04-28 22:41:09 -0700320 byte_count += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400321 /* is the result too big for the field? */
322 if (byte_count > USHRT_MAX)
323 return -EPROTO;
Jeff Layton820a8032011-05-04 08:05:26 -0400324 put_bcc(byte_count, pTargetSMB);
Steve Frenche4eb2952005-04-28 22:41:09 -0700325
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000326 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
Steve Frenche4eb2952005-04-28 22:41:09 -0700327 byte_count += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400328 /* don't allow buffer to overflow */
329 if (byte_count > CIFSMaxBufSize)
330 return -ENOBUFS;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000331 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
Steve Frenche4eb2952005-04-28 22:41:09 -0700332
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400333 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
334
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000335 if (remaining == total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000336 cFYI(1, "found the last secondary response");
Steve Frenche4eb2952005-04-28 22:41:09 -0700337 return 0; /* we are done */
338 } else /* more responses to go */
339 return 1;
Steve Frenche4eb2952005-04-28 22:41:09 -0700340}
341
Jeff Laytonc74093b2011-01-11 07:24:23 -0500342static void
343cifs_echo_request(struct work_struct *work)
344{
345 int rc;
346 struct TCP_Server_Info *server = container_of(work,
347 struct TCP_Server_Info, echo.work);
348
Jeff Layton247ec9b2011-02-04 17:09:50 -0500349 /*
Jeff Layton195291e2011-02-09 12:01:42 -0500350 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
351 * done, which is indicated by maxBuf != 0. Also, no need to ping if
352 * we got a response recently
Jeff Layton247ec9b2011-02-04 17:09:50 -0500353 */
Jeff Layton195291e2011-02-09 12:01:42 -0500354 if (server->maxBuf == 0 ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500355 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500356 goto requeue_echo;
357
358 rc = CIFSSMBEcho(server);
359 if (rc)
360 cFYI(1, "Unable to send echo request to server: %s",
361 server->hostname);
362
363requeue_echo:
364 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
365}
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367static int
368cifs_demultiplex_thread(struct TCP_Server_Info *server)
369{
370 int length;
371 unsigned int pdu_length, total_read;
372 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700373 struct smb_hdr *bigbuf = NULL;
374 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 struct msghdr smb_msg;
376 struct kvec iov;
377 struct socket *csocket = server->ssocket;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500378 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 struct task_struct *task_to_wake = NULL;
380 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700381 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000382 bool isLargeBuf = false;
383 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700384 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000387 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400388
389 length = atomic_inc_return(&tcpSesAllocCount);
390 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000391 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
392 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700394 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000395 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700396 if (try_to_freeze())
397 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700398 if (bigbuf == NULL) {
399 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000400 if (!bigbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000401 cERROR(1, "No memory for large SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700402 msleep(3000);
403 /* retry will check if exiting */
404 continue;
405 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000406 } else if (isLargeBuf) {
407 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000408 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700410
411 if (smallbuf == NULL) {
412 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000413 if (!smallbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000414 cERROR(1, "No memory for SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700415 msleep(1000);
416 /* retry will check if exiting */
417 continue;
418 }
419 /* beginning of smb buffer is cleared in our buf_get */
420 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000421 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700422
Steve French4b18f2a2008-04-29 00:06:05 +0000423 isLargeBuf = false;
424 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700425 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 iov.iov_base = smb_buffer;
427 iov.iov_len = 4;
428 smb_msg.msg_control = NULL;
429 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000430 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000431
Steve Frenchf01d5e12007-08-30 21:13:31 +0000432incomplete_rcv:
Steve Frenchfd88ce92011-04-12 01:01:14 +0000433 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
Steve Frenchfda35942011-01-20 18:06:34 +0000434 time_after(jiffies, server->lstrp +
435 (echo_retries * SMB_ECHO_INTERVAL))) {
436 cERROR(1, "Server %s has not responded in %d seconds. "
437 "Reconnecting...", server->hostname,
438 (echo_retries * SMB_ECHO_INTERVAL / HZ));
439 cifs_reconnect(server);
440 csocket = server->ssocket;
441 wake_up(&server->response_q);
442 continue;
443 }
444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 length =
446 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000447 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Jeff Layton469ee612008-10-16 18:46:39 +0000449 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 break;
451 } else if (server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000452 cFYI(1, "Reconnect after server stopped responding");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 cifs_reconnect(server);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000454 cFYI(1, "call to reconnect done");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 csocket = server->ssocket;
456 continue;
Jeff Layton522bbe62010-09-03 12:00:49 -0400457 } else if (length == -ERESTARTSYS ||
458 length == -EAGAIN ||
459 length == -EINTR) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700460 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 allowing socket to clear and app threads to set
462 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000463 if (pdu_length < 4) {
464 iov.iov_base = (4 - pdu_length) +
465 (char *)smb_buffer;
466 iov.iov_len = pdu_length;
467 smb_msg.msg_control = NULL;
468 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000469 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000470 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000471 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000473 cFYI(1, "Reconnect after unexpected peek error %d",
474 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 cifs_reconnect(server);
476 csocket = server->ssocket;
477 wake_up(&server->response_q);
478 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000479 } else if (length < pdu_length) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000480 cFYI(1, "requested %d bytes but only got %d bytes",
481 pdu_length, length);
Steve Frenchf01d5e12007-08-30 21:13:31 +0000482 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000483 msleep(1);
484 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 }
Steve French67010fb2005-04-28 22:41:09 -0700486
Steve French70ca7342005-09-22 16:32:06 -0700487 /* The right amount was read from socket - 4 bytes */
488 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700489
Steve French70ca7342005-09-22 16:32:06 -0700490 /* the first byte big endian of the length field,
491 is actually not part of the length but the type
492 with the most common, zero, as regular data */
493 temp = *((char *) smb_buffer);
494
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000495 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700496 but we convert it here so it is always manipulated
497 as host byte order */
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000498 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
Steve French46810cb2005-04-28 22:41:09 -0700499
Joe Perchesb6b38f72010-04-21 03:50:45 +0000500 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
Steve French70ca7342005-09-22 16:32:06 -0700501
502 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000503 continue;
Steve French70ca7342005-09-22 16:32:06 -0700504 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000505 cFYI(1, "Good RFC 1002 session rsp");
Steve Frenche4eb2952005-04-28 22:41:09 -0700506 continue;
Steve French70ca7342005-09-22 16:32:06 -0700507 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000508 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700509 an error on SMB negprot response */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000510 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
511 pdu_length);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400512 /* give server a second to clean up */
513 msleep(1000);
514 /* always try 445 first on reconnect since we get NACK
515 * on some if we ever connected to port 139 (the NACK
516 * is since we do not begin with RFC1001 session
517 * initialize frame)
518 */
Jeff Layton32670392010-09-03 12:00:50 -0400519 cifs_set_port((struct sockaddr *)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300520 &server->dstaddr, CIFS_PORT);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400521 cifs_reconnect(server);
522 csocket = server->ssocket;
523 wake_up(&server->response_q);
524 continue;
Steve French70ca7342005-09-22 16:32:06 -0700525 } else if (temp != (char) 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000526 cERROR(1, "Unknown RFC 1002 frame");
Steve French70ca7342005-09-22 16:32:06 -0700527 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
528 length);
Steve French46810cb2005-04-28 22:41:09 -0700529 cifs_reconnect(server);
530 csocket = server->ssocket;
531 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700532 }
533
534 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000535 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000536 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000537 cERROR(1, "Invalid size SMB length %d pdu_length %d",
538 length, pdu_length+4);
Steve Frenche4eb2952005-04-28 22:41:09 -0700539 cifs_reconnect(server);
540 csocket = server->ssocket;
541 wake_up(&server->response_q);
542 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000543 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700544
545 /* else length ok */
546 reconnect = 0;
547
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000548 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000549 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700550 memcpy(bigbuf, smallbuf, 4);
551 smb_buffer = bigbuf;
552 }
553 length = 0;
554 iov.iov_base = 4 + (char *)smb_buffer;
555 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000556 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700557 total_read += length) {
558 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
559 pdu_length - total_read, 0);
Jeff Layton522bbe62010-09-03 12:00:49 -0400560 if (server->tcpStatus == CifsExiting) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700561 /* then will exit */
562 reconnect = 2;
563 break;
564 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700565 cifs_reconnect(server);
566 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000567 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700568 /* Now we will reread sock */
569 reconnect = 1;
570 break;
Jeff Layton522bbe62010-09-03 12:00:49 -0400571 } else if (length == -ERESTARTSYS ||
572 length == -EAGAIN ||
573 length == -EINTR) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700574 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000575 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700576 threads to set tcpStatus
577 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000578 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700579 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700580 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000581 cERROR(1, "Received no data, expecting %d",
582 pdu_length - total_read);
Steve Frenche4eb2952005-04-28 22:41:09 -0700583 cifs_reconnect(server);
584 csocket = server->ssocket;
585 reconnect = 1;
586 break;
Steve French46810cb2005-04-28 22:41:09 -0700587 }
588 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000589 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700590 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000591 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700592 continue;
593
Jeff Layton9587fcf2011-02-01 08:40:43 -0500594 total_read += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000595
Jeff Layton9587fcf2011-02-01 08:40:43 -0500596 dump_smb(smb_buffer, total_read);
Jeff Layton71823ba2011-02-10 08:03:50 -0500597
598 /*
599 * We know that we received enough to get to the MID as we
600 * checked the pdu_length earlier. Now check to see
601 * if the rest of the header is OK. We borrow the length
602 * var for the rest of the loop to avoid a new stack var.
603 *
604 * 48 bytes is enough to display the header and a little bit
605 * into the payload for debugging purposes.
606 */
607 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
608 if (length != 0)
Jeff Layton9587fcf2011-02-01 08:40:43 -0500609 cifs_dump_mem("Bad SMB: ", smb_buffer,
Jeff Layton71823ba2011-02-10 08:03:50 -0500610 min_t(unsigned int, total_read, 48));
Steve Frenche4eb2952005-04-28 22:41:09 -0700611
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500612 mid_entry = NULL;
Steve Frenchfda35942011-01-20 18:06:34 +0000613 server->lstrp = jiffies;
614
Steve Frenche4eb2952005-04-28 22:41:09 -0700615 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500616 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700617 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
618
Jeff Layton146f9f62011-04-29 06:52:43 -0400619 if (mid_entry->mid != smb_buffer->Mid ||
620 mid_entry->midState != MID_REQUEST_SUBMITTED ||
621 mid_entry->command != smb_buffer->Command) {
622 mid_entry = NULL;
623 continue;
624 }
625
626 if (length == 0 &&
627 check2ndT2(smb_buffer, server->maxBuf) > 0) {
628 /* We have a multipart transact2 resp */
629 isMultiRsp = true;
630 if (mid_entry->resp_buf) {
631 /* merge response - fix up 1st*/
Jeff Layton16541ba2011-04-29 06:52:44 -0400632 length = coalesce_t2(smb_buffer,
633 mid_entry->resp_buf);
634 if (length > 0) {
635 length = 0;
Jeff Layton146f9f62011-04-29 06:52:43 -0400636 mid_entry->multiRsp = true;
637 break;
Steve Frenche4eb2952005-04-28 22:41:09 -0700638 } else {
Jeff Layton16541ba2011-04-29 06:52:44 -0400639 /* all parts received or
640 * packet is malformed
641 */
Jeff Layton146f9f62011-04-29 06:52:43 -0400642 mid_entry->multiEnd = true;
643 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700644 }
Jeff Layton146f9f62011-04-29 06:52:43 -0400645 } else {
646 if (!isLargeBuf) {
647 /*
648 * FIXME: switch to already
649 * allocated largebuf?
650 */
651 cERROR(1, "1st trans2 resp "
652 "needs bigbuf");
653 } else {
654 /* Have first buffer */
655 mid_entry->resp_buf =
656 smb_buffer;
657 mid_entry->largeBuf = true;
658 bigbuf = NULL;
659 }
Steve French50c2f752007-07-13 00:33:32 +0000660 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700661 break;
662 }
Jeff Layton146f9f62011-04-29 06:52:43 -0400663 mid_entry->resp_buf = smb_buffer;
664 mid_entry->largeBuf = isLargeBuf;
665multi_t2_fnd:
666 if (length == 0)
667 mid_entry->midState = MID_RESPONSE_RECEIVED;
668 else
669 mid_entry->midState = MID_RESPONSE_MALFORMED;
670#ifdef CONFIG_CIFS_STATS2
671 mid_entry->when_received = jiffies;
672#endif
673 list_del_init(&mid_entry->qhead);
674 mid_entry->callback(mid_entry);
675 break;
Steve Frenche4eb2952005-04-28 22:41:09 -0700676 }
677 spin_unlock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500678
679 if (mid_entry != NULL) {
Steve Frenchcd634992005-04-28 22:41:10 -0700680 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000681 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700682 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000683 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700684 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000685 else
Steve Frenchcd634992005-04-28 22:41:10 -0700686 smallbuf = NULL;
687 }
Jeff Layton71823ba2011-02-10 08:03:50 -0500688 } else if (length != 0) {
689 /* response sanity checks failed */
690 continue;
Steve French4b18f2a2008-04-29 00:06:05 +0000691 } else if (!is_valid_oplock_break(smb_buffer, server) &&
692 !isMultiRsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000693 cERROR(1, "No task to wake, unknown frame received! "
Jeff Layton80975312011-01-11 07:24:02 -0500694 "NumMids %d", atomic_read(&midCount));
Steve French50c2f752007-07-13 00:33:32 +0000695 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700696 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000697#ifdef CONFIG_CIFS_DEBUG2
698 cifs_dump_detail(smb_buffer);
699 cifs_dump_mids(server);
700#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000701
Steve Frenche4eb2952005-04-28 22:41:09 -0700702 }
703 } /* end while !EXITING */
704
Jeff Laytone7ddee92008-11-14 13:44:38 -0500705 /* take it off the list, if it's not already */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530706 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500707 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530708 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500709
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 spin_lock(&GlobalMid_Lock);
711 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000712 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000713 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000714
Steve French31ca3bc2005-04-28 22:41:11 -0700715 /* check if we have blocked requests that need to free */
716 /* Note that cifs_max_pending is normally 50, but
717 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000718 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000719 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700720 atomic_set(&server->inFlight, cifs_max_pending - 1);
721 /* We do not want to set the max_pending too low or we
722 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000724 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700726 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 to the same server - they now will see the session is in exit state
728 and get out of SendReceive. */
729 wake_up_all(&server->request_q);
730 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700731 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000732
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000733 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 sock_release(csocket);
735 server->ssocket = NULL;
736 }
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800737 /* buffer usually freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000738 cifs_buf_release(bigbuf);
739 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700740 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Jeff Layton9d783152011-01-11 07:24:01 -0500742 if (!list_empty(&server->pending_mid_q)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500744 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
Jeff Layton9d783152011-01-11 07:24:01 -0500745 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500746 cFYI(1, "Clearing Mid 0x%x - issuing callback",
747 mid_entry->mid);
748 list_del_init(&mid_entry->qhead);
749 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 }
751 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700753 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 }
755
Steve Frenchf1914012005-08-18 09:37:34 -0700756 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000757 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700759 /* due to delays on oplock break requests, we need
760 to wait at least 45 seconds before giving up
761 on a request getting a response and going ahead
762 and killing cifsd */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000763 cFYI(1, "Wait for exit from demultiplex thread");
Steve French31ca3bc2005-04-28 22:41:11 -0700764 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 /* if threads still have not exited they are probably never
766 coming home not much else we can do but free the memory */
767 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Jeff Laytonc359cf32007-11-16 22:22:06 +0000769 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400770 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700771 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400772
773 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000774 if (length > 0)
775 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
776 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000777
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400778 /* if server->tsk was NULL then wait for a signal before exiting */
779 if (!task_to_wake) {
780 set_current_state(TASK_INTERRUPTIBLE);
781 while (!signal_pending(current)) {
782 schedule();
783 set_current_state(TASK_INTERRUPTIBLE);
784 }
785 set_current_state(TASK_RUNNING);
786 }
787
Jeff Layton0468a2c2008-12-01 07:09:35 -0500788 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789}
790
Jeff Laytonc359cf32007-11-16 22:22:06 +0000791/* extract the host portion of the UNC string */
792static char *
793extract_hostname(const char *unc)
794{
795 const char *src;
796 char *dst, *delim;
797 unsigned int len;
798
799 /* skip double chars at beginning of string */
800 /* BB: check validity of these bytes? */
801 src = unc + 2;
802
803 /* delimiter between hostname and sharename is always '\\' now */
804 delim = strchr(src, '\\');
805 if (!delim)
806 return ERR_PTR(-EINVAL);
807
808 len = delim - src;
809 dst = kmalloc((len + 1), GFP_KERNEL);
810 if (dst == NULL)
811 return ERR_PTR(-ENOMEM);
812
813 memcpy(dst, src, len);
814 dst[len] = '\0';
815
816 return dst;
817}
818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819static int
Sean Finneyb9468452011-04-11 13:19:32 +0000820cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +0000821 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400823 char *value, *data, *end;
Sean Finneyb9468452011-04-11 13:19:32 +0000824 char *mountdata_copy, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 unsigned int temp_len, i, j;
826 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -0400827 short int override_uid = -1;
828 short int override_gid = -1;
829 bool uid_specified = false;
830 bool gid_specified = false;
Jeff Layton88463992010-11-22 15:31:03 -0500831 char *nodename = utsname()->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000834 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Jeff Layton88463992010-11-22 15:31:03 -0500836 /*
837 * does not have to be perfect mapping since field is
838 * informational, only used for servers that do not support
839 * port 445 and it can be overridden at mount time
840 */
Jeff Layton1397f2e2011-01-07 11:30:28 -0500841 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
842 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -0500843 vol->source_rfc1001_name[i] = toupper(nodename[i]);
844
Jeff Layton1397f2e2011-01-07 11:30:28 -0500845 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700846 /* null target name indicates to use *SMBSERVR default called name
847 if we end up sending RFC1001 session initialize */
848 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400849 vol->cred_uid = current_uid();
850 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +1100851 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400852
853 /* default to only allowing write access to owner of the mount */
854 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
856 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -0700857 /* default is always to request posix paths. */
858 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400859 /* default to using server inode numbers where available */
860 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700861
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530862 vol->actimeo = CIFS_DEF_ACTIMEO;
863
Sean Finneyb9468452011-04-11 13:19:32 +0000864 if (!mountdata)
865 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Sean Finneyb9468452011-04-11 13:19:32 +0000867 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
868 if (!mountdata_copy)
869 goto cifs_parse_mount_err;
870
871 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400872 end = options + strlen(options);
Steve French50c2f752007-07-13 00:33:32 +0000873 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000874 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 separator[0] = options[4];
876 options += 5;
877 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000878 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 }
880 }
Steve French50c2f752007-07-13 00:33:32 +0000881
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 while ((data = strsep(&options, separator)) != NULL) {
883 if (!*data)
884 continue;
885 if ((value = strchr(data, '=')) != NULL)
886 *value++ = '\0';
887
Steve French50c2f752007-07-13 00:33:32 +0000888 /* Have to parse this before we parse for "user" */
889 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000891 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 vol->no_xattr = 1;
893 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000894 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 printk(KERN_WARNING
896 "CIFS: invalid or missing username\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000897 goto cifs_parse_mount_err;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000898 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000899 /* null user, ie anonymous, authentication */
900 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 }
Steve French8727c8a2011-02-25 01:11:56 -0600902 if (strnlen(value, MAX_USERNAME_SIZE) <
903 MAX_USERNAME_SIZE) {
Sean Finneyb9468452011-04-11 13:19:32 +0000904 vol->username = kstrdup(value, GFP_KERNEL);
905 if (!vol->username) {
906 printk(KERN_WARNING "CIFS: no memory "
907 "for username\n");
908 goto cifs_parse_mount_err;
909 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 } else {
911 printk(KERN_WARNING "CIFS: username too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000912 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914 } else if (strnicmp(data, "pass", 4) == 0) {
915 if (!value) {
916 vol->password = NULL;
917 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000918 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 /* check if string begins with double comma
920 since that would mean the password really
921 does start with a comma, and would not
922 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000923 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 vol->password = NULL;
925 continue;
926 }
927 }
928 temp_len = strlen(value);
929 /* removed password length check, NTLM passwords
930 can be arbitrarily long */
931
Steve French50c2f752007-07-13 00:33:32 +0000932 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 prematurely null terminated. Commas in password are
934 specified across the cifs mount interface by a double
935 comma ie ,, and a comma used as in other cases ie ','
936 as a parameter delimiter/separator is single and due
937 to the strsep above is temporarily zeroed. */
938
939 /* NB: password legally can have multiple commas and
940 the only illegal character in a password is null */
941
Steve French50c2f752007-07-13 00:33:32 +0000942 if ((value[temp_len] == 0) &&
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400943 (value + temp_len < end) &&
Steve French09d1db52005-04-28 22:41:08 -0700944 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /* reinsert comma */
946 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000947 temp_len += 2; /* move after second comma */
948 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000950 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700951 separator[0]) {
952 /* skip second comma */
953 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000954 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 /* single comma indicating start
956 of next parm */
957 break;
958 }
959 }
960 temp_len++;
961 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000962 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 options = NULL;
964 } else {
965 value[temp_len] = 0;
966 /* point option to start of next parm */
967 options = value + temp_len + 1;
968 }
Steve French50c2f752007-07-13 00:33:32 +0000969 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 double commas to singles. Note that this ends up
971 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700972 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000973 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000974 printk(KERN_WARNING "CIFS: no memory "
975 "for password\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000976 goto cifs_parse_mount_err;
Steve French433dc242005-04-28 22:41:08 -0700977 }
Steve French50c2f752007-07-13 00:33:32 +0000978 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000980 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700981 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 /* skip second comma */
983 i++;
984 }
985 }
986 vol->password[j] = 0;
987 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700988 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000989 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000990 printk(KERN_WARNING "CIFS: no memory "
991 "for password\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000992 goto cifs_parse_mount_err;
Steve French433dc242005-04-28 22:41:08 -0700993 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 strcpy(vol->password, value);
995 }
Jeff Layton58f7f682009-06-10 09:57:55 -0400996 } else if (!strnicmp(data, "ip", 2) ||
997 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (!value || !*value) {
999 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -04001000 } else if (strnlen(value, INET6_ADDRSTRLEN) <
1001 INET6_ADDRSTRLEN) {
Sean Finneyb9468452011-04-11 13:19:32 +00001002 vol->UNCip = kstrdup(value, GFP_KERNEL);
1003 if (!vol->UNCip) {
1004 printk(KERN_WARNING "CIFS: no memory "
1005 "for UNC IP\n");
1006 goto cifs_parse_mount_err;
1007 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 } else {
Steve French50c2f752007-07-13 00:33:32 +00001009 printk(KERN_WARNING "CIFS: ip address "
1010 "too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001011 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 }
Steve French50c2f752007-07-13 00:33:32 +00001013 } else if (strnicmp(data, "sec", 3) == 0) {
1014 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001015 cERROR(1, "no security value specified");
Steve French50c2f752007-07-13 00:33:32 +00001016 continue;
1017 } else if (strnicmp(value, "krb5i", 5) == 0) {
1018 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +00001019 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001020 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001021 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1022 CIFSSEC_MAY_KRB5; */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001023 cERROR(1, "Krb5 cifs privacy not supported");
Sean Finneyb9468452011-04-11 13:19:32 +00001024 goto cifs_parse_mount_err;
Steve Frenchbf820672005-12-01 22:32:42 -08001025 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001026 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +00001027 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1028 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1029 CIFSSEC_MUST_SIGN;
1030 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1031 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
Steve Frenchbf820672005-12-01 22:32:42 -08001032 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001033 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +00001034 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001035 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001036 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -08001037 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001038 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +00001039 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001040 } else if (strnicmp(value, "ntlm", 4) == 0) {
1041 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001042 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001043 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001044 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001045 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001046#ifdef CONFIG_CIFS_WEAK_PW_HASH
1047 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001048 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001049#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001050 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001051 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001052 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001053 cERROR(1, "bad security option: %s", value);
Sean Finneyb9468452011-04-11 13:19:32 +00001054 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001055 }
Steve French1cb06d02011-02-24 18:07:19 +00001056 } else if (strnicmp(data, "vers", 3) == 0) {
1057 if (!value || !*value) {
1058 cERROR(1, "no protocol version specified"
1059 " after vers= mount option");
1060 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1061 (strnicmp(value, "1", 1) == 0)) {
1062 /* this is the default */
1063 continue;
Steve French1cb06d02011-02-24 18:07:19 +00001064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 } else if ((strnicmp(data, "unc", 3) == 0)
1066 || (strnicmp(data, "target", 6) == 0)
1067 || (strnicmp(data, "path", 4) == 0)) {
1068 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001069 printk(KERN_WARNING "CIFS: invalid path to "
1070 "network resource\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001071 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
1073 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001074 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001075 if (vol->UNC == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001076 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001077 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 if (strncmp(vol->UNC, "//", 2) == 0) {
1079 vol->UNC[0] = '\\';
1080 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001081 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001083 "CIFS: UNC Path does not begin "
1084 "with // or \\\\ \n");
Sean Finneyb9468452011-04-11 13:19:32 +00001085 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 }
1087 } else {
1088 printk(KERN_WARNING "CIFS: UNC name too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001089 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 }
1091 } else if ((strnicmp(data, "domain", 3) == 0)
1092 || (strnicmp(data, "workgroup", 5) == 0)) {
1093 if (!value || !*value) {
1094 printk(KERN_WARNING "CIFS: invalid domain name\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001095 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 }
1097 /* BB are there cases in which a comma can be valid in
1098 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001099 if (strnlen(value, 256) < 256) {
Sean Finneyb9468452011-04-11 13:19:32 +00001100 vol->domainname = kstrdup(value, GFP_KERNEL);
1101 if (!vol->domainname) {
1102 printk(KERN_WARNING "CIFS: no memory "
1103 "for domainname\n");
1104 goto cifs_parse_mount_err;
1105 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00001106 cFYI(1, "Domain name set");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 } else {
Steve French50c2f752007-07-13 00:33:32 +00001108 printk(KERN_WARNING "CIFS: domain name too "
1109 "long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001110 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 }
Ben Greear3eb9a882010-09-01 17:06:02 -07001112 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1113 vol->srcaddr.ss_family = AF_UNSPEC;
1114
1115 if (!value || !*value) {
1116 printk(KERN_WARNING "CIFS: srcaddr value"
1117 " not specified.\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001118 goto cifs_parse_mount_err;
Ben Greear3eb9a882010-09-01 17:06:02 -07001119 }
1120 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1121 value, strlen(value));
Dan Carpenterb235f372010-10-25 07:02:56 +02001122 if (i == 0) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001123 printk(KERN_WARNING "CIFS: Could not parse"
1124 " srcaddr: %s\n",
1125 value);
Sean Finneyb9468452011-04-11 13:19:32 +00001126 goto cifs_parse_mount_err;
Ben Greear3eb9a882010-09-01 17:06:02 -07001127 }
Steve French50c2f752007-07-13 00:33:32 +00001128 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1129 if (!value || !*value) {
1130 printk(KERN_WARNING
1131 "CIFS: invalid path prefix\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001132 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001133 }
1134 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001135 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001136 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001137 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1138 if (vol->prepath == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001139 goto cifs_parse_mount_err;
Steve French4523cc32007-04-30 20:13:06 +00001140 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001141 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001142 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001143 } else
Steve French50c2f752007-07-13 00:33:32 +00001144 strcpy(vol->prepath, value);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001145 cFYI(1, "prefix path %s", vol->prepath);
Steve French50c2f752007-07-13 00:33:32 +00001146 } else {
1147 printk(KERN_WARNING "CIFS: prefix too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001148 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 } else if (strnicmp(data, "iocharset", 9) == 0) {
1151 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001152 printk(KERN_WARNING "CIFS: invalid iocharset "
1153 "specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001154 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 }
1156 if (strnlen(value, 65) < 65) {
Sean Finneyb9468452011-04-11 13:19:32 +00001157 if (strnicmp(value, "default", 7)) {
1158 vol->iocharset = kstrdup(value,
1159 GFP_KERNEL);
1160
1161 if (!vol->iocharset) {
1162 printk(KERN_WARNING "CIFS: no "
1163 "memory for"
1164 "charset\n");
1165 goto cifs_parse_mount_err;
1166 }
1167 }
Steve French50c2f752007-07-13 00:33:32 +00001168 /* if iocharset not set then load_nls_default
1169 is used by caller */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001170 cFYI(1, "iocharset set to %s", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 } else {
Steve French63135e02007-07-17 17:34:02 +00001172 printk(KERN_WARNING "CIFS: iocharset name "
1173 "too long.\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001174 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001176 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1177 vol->linux_uid = simple_strtoul(value, &value, 0);
1178 uid_specified = true;
Jeff Laytonbd763312011-01-11 10:33:24 -05001179 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1180 vol->cred_uid = simple_strtoul(value, &value, 0);
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001181 } else if (!strnicmp(data, "forceuid", 8)) {
1182 override_uid = 1;
1183 } else if (!strnicmp(data, "noforceuid", 10)) {
1184 override_uid = 0;
1185 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1186 vol->linux_gid = simple_strtoul(value, &value, 0);
1187 gid_specified = true;
1188 } else if (!strnicmp(data, "forcegid", 8)) {
1189 override_gid = 1;
1190 } else if (!strnicmp(data, "noforcegid", 10)) {
1191 override_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 } else if (strnicmp(data, "file_mode", 4) == 0) {
1193 if (value && *value) {
1194 vol->file_mode =
1195 simple_strtoul(value, &value, 0);
1196 }
1197 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1198 if (value && *value) {
1199 vol->dir_mode =
1200 simple_strtoul(value, &value, 0);
1201 }
1202 } else if (strnicmp(data, "dirmode", 4) == 0) {
1203 if (value && *value) {
1204 vol->dir_mode =
1205 simple_strtoul(value, &value, 0);
1206 }
1207 } else if (strnicmp(data, "port", 4) == 0) {
1208 if (value && *value) {
1209 vol->port =
1210 simple_strtoul(value, &value, 0);
1211 }
1212 } else if (strnicmp(data, "rsize", 5) == 0) {
1213 if (value && *value) {
1214 vol->rsize =
1215 simple_strtoul(value, &value, 0);
1216 }
1217 } else if (strnicmp(data, "wsize", 5) == 0) {
1218 if (value && *value) {
1219 vol->wsize =
1220 simple_strtoul(value, &value, 0);
1221 }
1222 } else if (strnicmp(data, "sockopt", 5) == 0) {
Steve French6a5fa2362010-01-01 01:28:43 +00001223 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001224 cERROR(1, "no socket option specified");
Steve French6a5fa2362010-01-01 01:28:43 +00001225 continue;
1226 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1227 vol->sockopt_tcp_nodelay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 }
1229 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1230 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001231 cFYI(1, "invalid (empty) netbiosname");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 } else {
Jeff Layton1397f2e2011-01-07 11:30:28 -05001233 memset(vol->source_rfc1001_name, 0x20,
1234 RFC1001_NAME_LEN);
1235 /*
1236 * FIXME: are there cases in which a comma can
1237 * be valid in workstation netbios name (and
1238 * need special handling)?
1239 */
1240 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1241 /* don't ucase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001242 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 break;
Jeff Layton1397f2e2011-01-07 11:30:28 -05001244 vol->source_rfc1001_name[i] = value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
1246 /* The string has 16th byte zero still from
1247 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001248 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001249 printk(KERN_WARNING "CIFS: netbiosname"
1250 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001251 }
1252 } else if (strnicmp(data, "servern", 7) == 0) {
1253 /* servernetbiosname specified override *SMBSERVER */
1254 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001255 cFYI(1, "empty server netbiosname specified");
Steve Frencha10faeb22005-08-22 21:38:31 -07001256 } else {
1257 /* last byte, type, is 0x20 for servr type */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001258 memset(vol->target_rfc1001_name, 0x20,
1259 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001260
Steve French50c2f752007-07-13 00:33:32 +00001261 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001262 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001263 valid in this workstation netbios name
1264 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001265
Steve French50c2f752007-07-13 00:33:32 +00001266 /* user or mount helper must uppercase
1267 the netbiosname */
1268 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001269 break;
1270 else
Steve French50c2f752007-07-13 00:33:32 +00001271 vol->target_rfc1001_name[i] =
1272 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001273 }
1274 /* The string has 16th byte zero still from
1275 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001276 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001277 printk(KERN_WARNING "CIFS: server net"
1278 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 }
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301280 } else if (strnicmp(data, "actimeo", 7) == 0) {
1281 if (value && *value) {
1282 vol->actimeo = HZ * simple_strtoul(value,
1283 &value, 0);
1284 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1285 cERROR(1, "CIFS: attribute cache"
1286 "timeout too large");
Sean Finneyb9468452011-04-11 13:19:32 +00001287 goto cifs_parse_mount_err;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301288 }
1289 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 } else if (strnicmp(data, "credentials", 4) == 0) {
1291 /* ignore */
1292 } else if (strnicmp(data, "version", 3) == 0) {
1293 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001294 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 /* ignore */
Steve French71a394f2009-06-26 04:07:18 +00001296 } else if (strnicmp(data, "rw", 2) == 0) {
1297 /* ignore */
1298 } else if (strnicmp(data, "ro", 2) == 0) {
1299 /* ignore */
Steve Frenchedf1ae42008-10-29 00:47:57 +00001300 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1301 vol->noblocksnd = 1;
1302 } else if (strnicmp(data, "noautotune", 10) == 0) {
1303 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 } else if ((strnicmp(data, "suid", 4) == 0) ||
1305 (strnicmp(data, "nosuid", 6) == 0) ||
1306 (strnicmp(data, "exec", 4) == 0) ||
1307 (strnicmp(data, "noexec", 6) == 0) ||
1308 (strnicmp(data, "nodev", 5) == 0) ||
1309 (strnicmp(data, "noauto", 6) == 0) ||
1310 (strnicmp(data, "dev", 3) == 0)) {
1311 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001312 uses these opts to set flags, and the flags are read
1313 by the kernel vfs layer before we get here (ie
1314 before read super) so there is no point trying to
1315 parse these options again and set anything and it
1316 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 } else if (strnicmp(data, "hard", 4) == 0) {
1319 vol->retry = 1;
1320 } else if (strnicmp(data, "soft", 4) == 0) {
1321 vol->retry = 0;
1322 } else if (strnicmp(data, "perm", 4) == 0) {
1323 vol->noperm = 0;
1324 } else if (strnicmp(data, "noperm", 6) == 0) {
1325 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001326 } else if (strnicmp(data, "mapchars", 8) == 0) {
1327 vol->remap = 1;
1328 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1329 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001330 } else if (strnicmp(data, "sfu", 3) == 0) {
1331 vol->sfu_emul = 1;
1332 } else if (strnicmp(data, "nosfu", 5) == 0) {
1333 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001334 } else if (strnicmp(data, "nodfs", 5) == 0) {
1335 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001336 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1337 vol->posix_paths = 1;
1338 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1339 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001340 } else if (strnicmp(data, "nounix", 6) == 0) {
1341 vol->no_linux_ext = 1;
1342 } else if (strnicmp(data, "nolinux", 7) == 0) {
1343 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001344 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001345 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001346 vol->nocase = 1;
Jeff Laytonf636a342010-07-26 10:29:58 -04001347 } else if (strnicmp(data, "mand", 4) == 0) {
1348 /* ignore */
1349 } else if (strnicmp(data, "nomand", 6) == 0) {
1350 /* ignore */
1351 } else if (strnicmp(data, "_netdev", 7) == 0) {
1352 /* ignore */
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001353 } else if (strnicmp(data, "brl", 3) == 0) {
1354 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001355 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001356 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001357 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001358 /* turn off mandatory locking in mode
1359 if remote locking is turned off since the
1360 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001361 if (vol->file_mode ==
1362 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001363 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001364 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1365 /* will take the shorter form "forcemand" as well */
1366 /* This mount option will force use of mandatory
1367 (DOS/Windows style) byte range locks, instead of
1368 using posix advisory byte range locks, even if the
1369 Unix extensions are available and posix locks would
1370 be supported otherwise. If Unix extensions are not
1371 negotiated this has no effect since mandatory locks
1372 would be used (mandatory locks is all that those
1373 those servers support) */
1374 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 } else if (strnicmp(data, "setuids", 7) == 0) {
1376 vol->setuids = 1;
1377 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1378 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001379 } else if (strnicmp(data, "dynperm", 7) == 0) {
1380 vol->dynperm = true;
1381 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1382 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 } else if (strnicmp(data, "nohard", 6) == 0) {
1384 vol->retry = 0;
1385 } else if (strnicmp(data, "nosoft", 6) == 0) {
1386 vol->retry = 1;
1387 } else if (strnicmp(data, "nointr", 6) == 0) {
1388 vol->intr = 0;
1389 } else if (strnicmp(data, "intr", 4) == 0) {
1390 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001391 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1392 vol->nostrictsync = 1;
1393 } else if (strnicmp(data, "strictsync", 10) == 0) {
1394 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001395 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001397 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001399 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001400 vol->cifs_acl = 1;
1401 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1402 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001403 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001405 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001407 } else if (strnicmp(data, "locallease", 6) == 0) {
1408 vol->local_lease = 1;
Steve French50c2f752007-07-13 00:33:32 +00001409 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001410 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001411 } else if (strnicmp(data, "seal", 4) == 0) {
1412 /* we do not do the following in secFlags because seal
1413 is a per tree connection (mount) not a per socket
1414 or per-smb connection option in the protocol */
1415 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1416 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001417 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001419 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 vol->direct_io = 1;
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05001421 } else if (strnicmp(data, "strictcache", 11) == 0) {
1422 vol->strict_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001424 printk(KERN_WARNING "CIFS: Mount option noac not "
1425 "supported. Instead set "
1426 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301427 } else if (strnicmp(data, "fsc", 3) == 0) {
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301428#ifndef CONFIG_CIFS_FSCACHE
1429 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1430 "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;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001434 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1435 vol->mfsymlinks = true;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001436 } else if (strnicmp(data, "multiuser", 8) == 0) {
1437 vol->multiuser = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 } else
Steve French50c2f752007-07-13 00:33:32 +00001439 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1440 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 }
1442 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001443 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001444 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1445 "target\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001446 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 }
1448 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001449 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001450 if (vol->UNC == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001451 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001452 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 if (strncmp(vol->UNC, "//", 2) == 0) {
1454 vol->UNC[0] = '\\';
1455 vol->UNC[1] = '\\';
1456 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001457 printk(KERN_WARNING "CIFS: UNC Path does not "
1458 "begin with // or \\\\ \n");
Sean Finneyb9468452011-04-11 13:19:32 +00001459 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001461 value = strpbrk(vol->UNC+2, "/\\");
1462 if (value)
1463 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 } else {
1465 printk(KERN_WARNING "CIFS: UNC name too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001466 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 }
1468 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001469
1470 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1471 cERROR(1, "Multiuser mounts currently require krb5 "
1472 "authentication!");
Sean Finneyb9468452011-04-11 13:19:32 +00001473 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001474 }
1475
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001476 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 vol->UNCip = &vol->UNC[2];
1478
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001479 if (uid_specified)
1480 vol->override_uid = override_uid;
1481 else if (override_uid == 1)
1482 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1483 "specified with no uid= option.\n");
1484
1485 if (gid_specified)
1486 vol->override_gid = override_gid;
1487 else if (override_gid == 1)
1488 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1489 "specified with no gid= option.\n");
1490
Sean Finneyb9468452011-04-11 13:19:32 +00001491 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001493
1494cifs_parse_mount_err:
1495 kfree(mountdata_copy);
1496 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497}
1498
Ben Greear3eb9a882010-09-01 17:06:02 -07001499/** Returns true if srcaddr isn't specified and rhs isn't
1500 * specified, or if srcaddr is specified and
1501 * matches the IP address of the rhs argument.
1502 */
Jeff Layton45151482010-07-06 20:43:02 -04001503static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001504srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1505{
1506 switch (srcaddr->sa_family) {
1507 case AF_UNSPEC:
1508 return (rhs->sa_family == AF_UNSPEC);
1509 case AF_INET: {
1510 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1511 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1512 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1513 }
1514 case AF_INET6: {
1515 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1516 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1517 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1518 }
1519 default:
1520 WARN_ON(1);
1521 return false; /* don't expect to be here */
1522 }
1523}
1524
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001525/*
1526 * If no port is specified in addr structure, we try to match with 445 port
1527 * and if it fails - with 139 ports. It should be called only if address
1528 * families of server and addr are equal.
1529 */
1530static bool
1531match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1532{
Steve French6da97912011-03-13 18:55:55 +00001533 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001534
1535 switch (addr->sa_family) {
1536 case AF_INET:
1537 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1538 port = ((struct sockaddr_in *) addr)->sin_port;
1539 break;
1540 case AF_INET6:
1541 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1542 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1543 break;
1544 default:
1545 WARN_ON(1);
1546 return false;
1547 }
1548
1549 if (!port) {
1550 port = htons(CIFS_PORT);
1551 if (port == *sport)
1552 return true;
1553
1554 port = htons(RFC1001_PORT);
1555 }
1556
1557 return port == *sport;
1558}
Ben Greear3eb9a882010-09-01 17:06:02 -07001559
1560static bool
1561match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1562 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563{
Jeff Layton45151482010-07-06 20:43:02 -04001564 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001565 case AF_INET: {
1566 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1567 struct sockaddr_in *srv_addr4 =
1568 (struct sockaddr_in *)&server->dstaddr;
1569
1570 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001571 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001572 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001573 }
1574 case AF_INET6: {
1575 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1576 struct sockaddr_in6 *srv_addr6 =
1577 (struct sockaddr_in6 *)&server->dstaddr;
1578
Jeff Layton45151482010-07-06 20:43:02 -04001579 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001580 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001581 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001582 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001583 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001584 break;
1585 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001586 default:
1587 WARN_ON(1);
1588 return false; /* don't expect to be here */
1589 }
Jeff Layton45151482010-07-06 20:43:02 -04001590
Ben Greear3eb9a882010-09-01 17:06:02 -07001591 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1592 return false;
1593
Jeff Layton45151482010-07-06 20:43:02 -04001594 return true;
1595}
1596
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001597static bool
1598match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1599{
1600 unsigned int secFlags;
1601
1602 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1603 secFlags = vol->secFlg;
1604 else
1605 secFlags = global_secflags | vol->secFlg;
1606
1607 switch (server->secType) {
1608 case LANMAN:
1609 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1610 return false;
1611 break;
1612 case NTLMv2:
1613 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1614 return false;
1615 break;
1616 case NTLM:
1617 if (!(secFlags & CIFSSEC_MAY_NTLM))
1618 return false;
1619 break;
1620 case Kerberos:
1621 if (!(secFlags & CIFSSEC_MAY_KRB5))
1622 return false;
1623 break;
1624 case RawNTLMSSP:
1625 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1626 return false;
1627 break;
1628 default:
1629 /* shouldn't happen */
1630 return false;
1631 }
1632
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001633 /* now check if signing mode is acceptable */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001634 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1635 (server->secMode & SECMODE_SIGN_REQUIRED))
1636 return false;
1637 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1638 (server->secMode &
1639 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1640 return false;
1641
1642 return true;
1643}
1644
Jeff Layton45151482010-07-06 20:43:02 -04001645static struct TCP_Server_Info *
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001646cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04001647{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001648 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301650 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04001651 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06001652 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1653 continue;
1654
Ben Greear3eb9a882010-09-01 17:06:02 -07001655 if (!match_address(server, addr,
1656 (struct sockaddr *)&vol->srcaddr))
Jeff Layton45151482010-07-06 20:43:02 -04001657 continue;
Steve French50c2f752007-07-13 00:33:32 +00001658
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001659 if (!match_port(server, addr))
1660 continue;
1661
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001662 if (!match_security(server, vol))
1663 continue;
1664
Jeff Laytone7ddee92008-11-14 13:44:38 -05001665 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301666 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001667 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05001668 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301670 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 return NULL;
1672}
1673
Jeff Layton14fbf502008-11-14 13:53:46 -05001674static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001675cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001677 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301679 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001680 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301681 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001682 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001684
Rob Landleyf1d0c992011-01-22 15:44:05 -06001685 put_net(cifs_net_ns(server));
1686
Jeff Laytone7ddee92008-11-14 13:44:38 -05001687 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301688 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001689
Jeff Laytonc74093b2011-01-11 07:24:23 -05001690 cancel_delayed_work_sync(&server->echo);
1691
Jeff Laytone7ddee92008-11-14 13:44:38 -05001692 spin_lock(&GlobalMid_Lock);
1693 server->tcpStatus = CifsExiting;
1694 spin_unlock(&GlobalMid_Lock);
1695
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001696 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301697 cifs_fscache_release_client_cookie(server);
1698
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05001699 kfree(server->session_key.response);
1700 server->session_key.response = NULL;
1701 server->session_key.len = 0;
1702
Jeff Laytone7ddee92008-11-14 13:44:38 -05001703 task = xchg(&server->tsk, NULL);
1704 if (task)
1705 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706}
1707
Jeff Layton63c038c2008-12-01 18:41:46 -05001708static struct TCP_Server_Info *
1709cifs_get_tcp_session(struct smb_vol *volume_info)
1710{
1711 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001712 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001713 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1714 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1715 int rc;
1716
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001717 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001718
Joe Perchesb6b38f72010-04-21 03:50:45 +00001719 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001720
Jeff Layton63c038c2008-12-01 18:41:46 -05001721 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton50d97162010-07-06 20:43:01 -04001722 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1723 volume_info->UNCip,
David Howells67b76262010-07-22 18:33:01 +01001724 strlen(volume_info->UNCip),
Jeff Layton50d97162010-07-06 20:43:01 -04001725 volume_info->port);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001726 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001727 /* we failed translating address */
1728 rc = -EINVAL;
1729 goto out_err;
1730 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001731 } else if (volume_info->UNCip) {
1732 /* BB using ip addr as tcp_ses name to connect to the
1733 DFS root below */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001734 cERROR(1, "Connecting to DFS root not implemented yet");
Jeff Layton63c038c2008-12-01 18:41:46 -05001735 rc = -EINVAL;
1736 goto out_err;
1737 } else /* which tcp_sess DFS root would we conect to */ {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001738 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1739 "unc=//192.168.1.100/public) specified");
Jeff Layton63c038c2008-12-01 18:41:46 -05001740 rc = -EINVAL;
1741 goto out_err;
1742 }
1743
1744 /* see if we already have a matching tcp_ses */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001745 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05001746 if (tcp_ses)
1747 return tcp_ses;
1748
1749 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1750 if (!tcp_ses) {
1751 rc = -ENOMEM;
1752 goto out_err;
1753 }
1754
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001755 rc = cifs_crypto_shash_allocate(tcp_ses);
1756 if (rc) {
1757 cERROR(1, "could not setup hash structures rc %d", rc);
1758 goto out_err;
1759 }
1760
Rob Landleyf1d0c992011-01-22 15:44:05 -06001761 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05001762 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1763 if (IS_ERR(tcp_ses->hostname)) {
1764 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001765 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001766 }
1767
1768 tcp_ses->noblocksnd = volume_info->noblocksnd;
1769 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00001770 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Jeff Layton63c038c2008-12-01 18:41:46 -05001771 atomic_set(&tcp_ses->inFlight, 0);
1772 init_waitqueue_head(&tcp_ses->response_q);
1773 init_waitqueue_head(&tcp_ses->request_q);
1774 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1775 mutex_init(&tcp_ses->srv_mutex);
1776 memcpy(tcp_ses->workstation_RFC1001_name,
1777 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1778 memcpy(tcp_ses->server_RFC1001_name,
1779 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05001780 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05001781 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00001782 tcp_ses->lstrp = jiffies;
Jeff Layton63c038c2008-12-01 18:41:46 -05001783 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1784 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05001785 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton63c038c2008-12-01 18:41:46 -05001786
1787 /*
1788 * at this point we are the only ones with the pointer
1789 * to the struct since the kernel thread not created yet
1790 * no need to spinlock this init of tcpStatus or srv_count
1791 */
1792 tcp_ses->tcpStatus = CifsNew;
Ben Greear3eb9a882010-09-01 17:06:02 -07001793 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1794 sizeof(tcp_ses->srcaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05001795 ++tcp_ses->srv_count;
1796
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001797 if (addr.ss_family == AF_INET6) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001798 cFYI(1, "attempting ipv6 connect");
Jeff Layton63c038c2008-12-01 18:41:46 -05001799 /* BB should we allow ipv6 on port 139? */
1800 /* other OS never observed in Wild doing 139 with v6 */
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001801 memcpy(&tcp_ses->dstaddr, sin_server6,
1802 sizeof(struct sockaddr_in6));
1803 } else
1804 memcpy(&tcp_ses->dstaddr, sin_server,
1805 sizeof(struct sockaddr_in));
1806
1807 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001808 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001809 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001810 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001811 }
1812
1813 /*
1814 * since we're in a cifs function already, we know that
1815 * this will succeed. No need for try_module_get().
1816 */
1817 __module_get(THIS_MODULE);
1818 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1819 tcp_ses, "cifsd");
1820 if (IS_ERR(tcp_ses->tsk)) {
1821 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001822 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05001823 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001824 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001825 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00001826 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05001827
1828 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301829 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001830 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301831 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001832
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301833 cifs_fscache_get_client_cookie(tcp_ses);
1834
Jeff Laytonc74093b2011-01-11 07:24:23 -05001835 /* queue echo request delayed work */
1836 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1837
Jeff Layton63c038c2008-12-01 18:41:46 -05001838 return tcp_ses;
1839
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001840out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001841 cifs_crypto_shash_release(tcp_ses);
1842
Rob Landleyf1d0c992011-01-22 15:44:05 -06001843 put_net(cifs_net_ns(tcp_ses));
1844
Jeff Layton63c038c2008-12-01 18:41:46 -05001845out_err:
1846 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00001847 if (!IS_ERR(tcp_ses->hostname))
1848 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05001849 if (tcp_ses->ssocket)
1850 sock_release(tcp_ses->ssocket);
1851 kfree(tcp_ses);
1852 }
1853 return ERR_PTR(rc);
1854}
1855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856static struct cifsSesInfo *
Jeff Layton4ff67b72010-07-06 20:43:02 -04001857cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 struct cifsSesInfo *ses;
1860
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301861 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04001862 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1863 switch (server->secType) {
1864 case Kerberos:
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001865 if (vol->cred_uid != ses->cred_uid)
Jeff Layton4ff67b72010-07-06 20:43:02 -04001866 continue;
1867 break;
1868 default:
1869 /* anything else takes username/password */
Steve French8727c8a2011-02-25 01:11:56 -06001870 if (ses->user_name == NULL)
1871 continue;
1872 if (strncmp(ses->user_name, vol->username,
Jeff Layton4ff67b72010-07-06 20:43:02 -04001873 MAX_USERNAME_SIZE))
1874 continue;
1875 if (strlen(vol->username) != 0 &&
Jeff Layton24e6cf92010-08-23 11:38:04 -04001876 ses->password != NULL &&
Jeff Laytonfc87a402010-08-18 13:13:39 -04001877 strncmp(ses->password,
1878 vol->password ? vol->password : "",
Jeff Layton4ff67b72010-07-06 20:43:02 -04001879 MAX_PASSWORD_SIZE))
1880 continue;
1881 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001882 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301883 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001884 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301886 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 return NULL;
1888}
1889
Jeff Layton14fbf502008-11-14 13:53:46 -05001890static void
1891cifs_put_smb_ses(struct cifsSesInfo *ses)
1892{
1893 int xid;
1894 struct TCP_Server_Info *server = ses->server;
1895
Jeff Layton36988c72010-04-24 07:57:43 -04001896 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301897 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001898 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301899 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001900 return;
1901 }
1902
1903 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301904 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001905
1906 if (ses->status == CifsGood) {
1907 xid = GetXid();
1908 CIFSSMBLogoff(xid, ses);
1909 _FreeXid(xid);
1910 }
1911 sesInfoFree(ses);
1912 cifs_put_tcp_session(server);
1913}
1914
Steve Frenchd9b94202011-04-12 01:24:57 +00001915static bool warned_on_ntlm; /* globals init to false automatically */
1916
Jeff Layton36988c72010-04-24 07:57:43 -04001917static struct cifsSesInfo *
1918cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1919{
1920 int rc = -ENOMEM, xid;
1921 struct cifsSesInfo *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001922 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1923 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04001924
1925 xid = GetXid();
1926
Jeff Layton4ff67b72010-07-06 20:43:02 -04001927 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04001928 if (ses) {
1929 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1930
Jeff Layton36988c72010-04-24 07:57:43 -04001931 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001932 rc = cifs_negotiate_protocol(xid, ses);
1933 if (rc) {
1934 mutex_unlock(&ses->session_mutex);
1935 /* problem -- put our ses reference */
1936 cifs_put_smb_ses(ses);
1937 FreeXid(xid);
1938 return ERR_PTR(rc);
1939 }
Jeff Layton36988c72010-04-24 07:57:43 -04001940 if (ses->need_reconnect) {
1941 cFYI(1, "Session needs reconnect");
1942 rc = cifs_setup_session(xid, ses,
1943 volume_info->local_nls);
1944 if (rc) {
1945 mutex_unlock(&ses->session_mutex);
1946 /* problem -- put our reference */
1947 cifs_put_smb_ses(ses);
1948 FreeXid(xid);
1949 return ERR_PTR(rc);
1950 }
1951 }
1952 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04001953
1954 /* existing SMB ses has a server reference already */
1955 cifs_put_tcp_session(server);
Jeff Layton36988c72010-04-24 07:57:43 -04001956 FreeXid(xid);
1957 return ses;
1958 }
1959
1960 cFYI(1, "Existing smb sess not found");
1961 ses = sesInfoAlloc();
1962 if (ses == NULL)
1963 goto get_ses_fail;
1964
1965 /* new SMB session uses our server ref */
1966 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001967 if (server->dstaddr.ss_family == AF_INET6)
1968 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04001969 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001970 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04001971
Steve French8727c8a2011-02-25 01:11:56 -06001972 if (volume_info->username) {
1973 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1974 if (!ses->user_name)
1975 goto get_ses_fail;
1976 }
Jeff Layton36988c72010-04-24 07:57:43 -04001977
1978 /* volume_info->password freed at unmount */
1979 if (volume_info->password) {
1980 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1981 if (!ses->password)
1982 goto get_ses_fail;
1983 }
1984 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05001985 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1986 if (!ses->domainName)
1987 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04001988 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001989 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04001990 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00001991
1992 /* ntlmv2 is much stronger than ntlm security, and has been broadly
1993 supported for many years, time to update default security mechanism */
1994 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1995 warned_on_ntlm = true;
1996 cERROR(1, "default security mechanism requested. The default "
1997 "security mechanism will be upgraded from ntlm to "
1998 "ntlmv2 in kernel release 2.6.41");
1999 }
Jeff Layton36988c72010-04-24 07:57:43 -04002000 ses->overrideSecFlg = volume_info->secFlg;
2001
2002 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002003 rc = cifs_negotiate_protocol(xid, ses);
2004 if (!rc)
2005 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002006 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002007 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002008 goto get_ses_fail;
2009
2010 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302011 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002012 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302013 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002014
2015 FreeXid(xid);
2016 return ses;
2017
2018get_ses_fail:
2019 sesInfoFree(ses);
2020 FreeXid(xid);
2021 return ERR_PTR(rc);
2022}
2023
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05002025cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026{
2027 struct list_head *tmp;
2028 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302030 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002031 list_for_each(tmp, &ses->tcon_list) {
2032 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
2033 if (tcon->tidStatus == CifsExiting)
2034 continue;
2035 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 continue;
2037
Jeff Laytonf1987b42008-11-15 11:12:47 -05002038 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302039 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 return tcon;
2041 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302042 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 return NULL;
2044}
2045
Jeff Laytonf1987b42008-11-15 11:12:47 -05002046static void
2047cifs_put_tcon(struct cifsTconInfo *tcon)
2048{
2049 int xid;
2050 struct cifsSesInfo *ses = tcon->ses;
2051
Jeff Laytond00c28d2010-04-24 07:57:44 -04002052 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302053 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002054 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302055 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002056 return;
2057 }
2058
2059 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302060 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002061
2062 xid = GetXid();
2063 CIFSSMBTDis(xid, tcon);
2064 _FreeXid(xid);
2065
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302066 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002067 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002068 cifs_put_smb_ses(ses);
2069}
2070
Jeff Laytond00c28d2010-04-24 07:57:44 -04002071static struct cifsTconInfo *
2072cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2073{
2074 int rc, xid;
2075 struct cifsTconInfo *tcon;
2076
2077 tcon = cifs_find_tcon(ses, volume_info->UNC);
2078 if (tcon) {
2079 cFYI(1, "Found match on UNC path");
2080 /* existing tcon already has a reference */
2081 cifs_put_smb_ses(ses);
2082 if (tcon->seal != volume_info->seal)
2083 cERROR(1, "transport encryption setting "
2084 "conflicts with existing tid");
2085 return tcon;
2086 }
2087
2088 tcon = tconInfoAlloc();
2089 if (tcon == NULL) {
2090 rc = -ENOMEM;
2091 goto out_fail;
2092 }
2093
2094 tcon->ses = ses;
2095 if (volume_info->password) {
2096 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2097 if (!tcon->password) {
2098 rc = -ENOMEM;
2099 goto out_fail;
2100 }
2101 }
2102
2103 if (strchr(volume_info->UNC + 3, '\\') == NULL
2104 && strchr(volume_info->UNC + 3, '/') == NULL) {
2105 cERROR(1, "Missing share name");
2106 rc = -ENODEV;
2107 goto out_fail;
2108 }
2109
2110 /* BB Do we need to wrap session_mutex around
2111 * this TCon call and Unix SetFS as
2112 * we do on SessSetup and reconnect? */
2113 xid = GetXid();
2114 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2115 FreeXid(xid);
2116 cFYI(1, "CIFS Tcon rc = %d", rc);
2117 if (rc)
2118 goto out_fail;
2119
2120 if (volume_info->nodfs) {
2121 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2122 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2123 }
2124 tcon->seal = volume_info->seal;
2125 /* we can have only one retry value for a connection
2126 to a share so for resources mounted more than once
2127 to the same server share the last value passed in
2128 for the retry flag is used */
2129 tcon->retry = volume_info->retry;
2130 tcon->nocase = volume_info->nocase;
2131 tcon->local_lease = volume_info->local_lease;
2132
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302133 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002134 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302135 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002136
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302137 cifs_fscache_get_super_cookie(tcon);
2138
Jeff Laytond00c28d2010-04-24 07:57:44 -04002139 return tcon;
2140
2141out_fail:
2142 tconInfoFree(tcon);
2143 return ERR_PTR(rc);
2144}
2145
Jeff Layton9d002df2010-10-06 19:51:11 -04002146void
2147cifs_put_tlink(struct tcon_link *tlink)
2148{
2149 if (!tlink || IS_ERR(tlink))
2150 return;
2151
2152 if (!atomic_dec_and_test(&tlink->tl_count) ||
2153 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2154 tlink->tl_time = jiffies;
2155 return;
2156 }
2157
2158 if (!IS_ERR(tlink_tcon(tlink)))
2159 cifs_put_tcon(tlink_tcon(tlink));
2160 kfree(tlink);
2161 return;
2162}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002163
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164int
Steve French50c2f752007-07-13 00:33:32 +00002165get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2166 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00002167 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168{
2169 char *temp_unc;
2170 int rc = 0;
2171
2172 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00002173 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
2175 if (pSesInfo->ipc_tid == 0) {
2176 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00002177 strnlen(pSesInfo->serverName,
2178 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 + 1 + 4 /* slash IPC$ */ + 2,
2180 GFP_KERNEL);
2181 if (temp_unc == NULL)
2182 return -ENOMEM;
2183 temp_unc[0] = '\\';
2184 temp_unc[1] = '\\';
2185 strcpy(temp_unc + 2, pSesInfo->serverName);
2186 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2187 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002188 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 kfree(temp_unc);
2190 }
2191 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00002192 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07002193 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00002194 /* BB map targetUNCs to dfs_info3 structures, here or
2195 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
2197 return rc;
2198}
2199
Jeff Layton09e50d52008-07-23 10:11:19 -04002200#ifdef CONFIG_DEBUG_LOCK_ALLOC
2201static struct lock_class_key cifs_key[2];
2202static struct lock_class_key cifs_slock_key[2];
2203
2204static inline void
2205cifs_reclassify_socket4(struct socket *sock)
2206{
2207 struct sock *sk = sock->sk;
2208 BUG_ON(sock_owned_by_user(sk));
2209 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2210 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2211}
2212
2213static inline void
2214cifs_reclassify_socket6(struct socket *sock)
2215{
2216 struct sock *sk = sock->sk;
2217 BUG_ON(sock_owned_by_user(sk));
2218 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2219 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2220}
2221#else
2222static inline void
2223cifs_reclassify_socket4(struct socket *sock)
2224{
2225}
2226
2227static inline void
2228cifs_reclassify_socket6(struct socket *sock)
2229{
2230}
2231#endif
2232
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002234static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235{
Steve French50c2f752007-07-13 00:33:32 +00002236 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
Steve French50c2f752007-07-13 00:33:32 +00002238 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 /* mask a nibble at a time and encode */
2240 target[j] = 'A' + (0x0F & (source[i] >> 4));
2241 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002242 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 }
2244
2245}
2246
Ben Greear3eb9a882010-09-01 17:06:02 -07002247static int
2248bind_socket(struct TCP_Server_Info *server)
2249{
2250 int rc = 0;
2251 if (server->srcaddr.ss_family != AF_UNSPEC) {
2252 /* Bind to the specified local IP address */
2253 struct socket *socket = server->ssocket;
2254 rc = socket->ops->bind(socket,
2255 (struct sockaddr *) &server->srcaddr,
2256 sizeof(server->srcaddr));
2257 if (rc < 0) {
2258 struct sockaddr_in *saddr4;
2259 struct sockaddr_in6 *saddr6;
2260 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2261 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2262 if (saddr6->sin6_family == AF_INET6)
2263 cERROR(1, "cifs: "
2264 "Failed to bind to: %pI6c, error: %d\n",
2265 &saddr6->sin6_addr, rc);
2266 else
2267 cERROR(1, "cifs: "
2268 "Failed to bind to: %pI4, error: %d\n",
2269 &saddr4->sin_addr.s_addr, rc);
2270 }
2271 }
2272 return rc;
2273}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274
2275static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002276ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277{
2278 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002279 /*
2280 * some servers require RFC1001 sessinit before sending
2281 * negprot - BB check reconnection in case where second
2282 * sessinit is sent but no second negprot
2283 */
2284 struct rfc1002_session_packet *ses_init_buf;
2285 struct smb_hdr *smb_buf;
2286 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2287 GFP_KERNEL);
2288 if (ses_init_buf) {
2289 ses_init_buf->trailer.session_req.called_len = 32;
2290
2291 if (server->server_RFC1001_name &&
2292 server->server_RFC1001_name[0] != 0)
2293 rfc1002mangle(ses_init_buf->trailer.
2294 session_req.called_name,
2295 server->server_RFC1001_name,
2296 RFC1001_NAME_LEN_WITH_NULL);
2297 else
2298 rfc1002mangle(ses_init_buf->trailer.
2299 session_req.called_name,
2300 DEFAULT_CIFS_CALLED_NAME,
2301 RFC1001_NAME_LEN_WITH_NULL);
2302
2303 ses_init_buf->trailer.session_req.calling_len = 32;
2304
2305 /*
2306 * calling name ends in null (byte 16) from old smb
2307 * convention.
2308 */
2309 if (server->workstation_RFC1001_name &&
2310 server->workstation_RFC1001_name[0] != 0)
2311 rfc1002mangle(ses_init_buf->trailer.
2312 session_req.calling_name,
2313 server->workstation_RFC1001_name,
2314 RFC1001_NAME_LEN_WITH_NULL);
2315 else
2316 rfc1002mangle(ses_init_buf->trailer.
2317 session_req.calling_name,
2318 "LINUX_CIFS_CLNT",
2319 RFC1001_NAME_LEN_WITH_NULL);
2320
2321 ses_init_buf->trailer.session_req.scope1 = 0;
2322 ses_init_buf->trailer.session_req.scope2 = 0;
2323 smb_buf = (struct smb_hdr *)ses_init_buf;
2324
2325 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002326 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002327 rc = smb_send(server, smb_buf, 0x44);
2328 kfree(ses_init_buf);
2329 /*
2330 * RFC1001 layer in at least one server
2331 * requires very short break before negprot
2332 * presumably because not expecting negprot
2333 * to follow so fast. This is a simple
2334 * solution that works without
2335 * complicating the code and causes no
2336 * significant slowing down on mount
2337 * for everyone else
2338 */
2339 usleep_range(1000, 2000);
2340 }
2341 /*
2342 * else the negprot may still work without this
2343 * even though malloc failed
2344 */
2345
2346 return rc;
2347}
2348
2349static int
2350generic_ip_connect(struct TCP_Server_Info *server)
2351{
2352 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00002353 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002354 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002355 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002356 struct sockaddr *saddr;
2357
2358 saddr = (struct sockaddr *) &server->dstaddr;
2359
2360 if (server->dstaddr.ss_family == AF_INET6) {
2361 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2362 slen = sizeof(struct sockaddr_in6);
2363 sfamily = AF_INET6;
2364 } else {
2365 sport = ((struct sockaddr_in *) saddr)->sin_port;
2366 slen = sizeof(struct sockaddr_in);
2367 sfamily = AF_INET;
2368 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002370 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06002371 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2372 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002374 cERROR(1, "Error %d creating socket", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002375 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002378
2379 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002380 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002381 server->ssocket = socket;
2382 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002383 if (sfamily == AF_INET6)
2384 cifs_reclassify_socket6(socket);
2385 else
2386 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 }
2388
Ben Greear3eb9a882010-09-01 17:06:02 -07002389 rc = bind_socket(server);
2390 if (rc < 0)
2391 return rc;
2392
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002393 rc = socket->ops->connect(socket, saddr, slen, 0);
2394 if (rc < 0) {
2395 cFYI(1, "Error %d connecting to server", rc);
Jeff Laytond5c56052008-12-01 18:42:33 -05002396 sock_release(socket);
2397 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 return rc;
2399 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00002400
Jeff Laytond5c56052008-12-01 18:42:33 -05002401 /*
2402 * Eventually check for other socket options to change from
2403 * the default. sock_setsockopt not used because it expects
2404 * user space buffer
2405 */
2406 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002407 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00002408
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002409 /* make the bufsizes depend on wsize/rsize and max requests */
2410 if (server->noautotune) {
2411 if (socket->sk->sk_sndbuf < (200 * 1024))
2412 socket->sk->sk_sndbuf = 200 * 1024;
2413 if (socket->sk->sk_rcvbuf < (140 * 1024))
2414 socket->sk->sk_rcvbuf = 140 * 1024;
2415 }
2416
Steve French6a5fa2362010-01-01 01:28:43 +00002417 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002418 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00002419 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2420 (char *)&val, sizeof(val));
2421 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002422 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002423 }
2424
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002425 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2426 socket->sk->sk_sndbuf,
2427 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2428
2429 if (sport == htons(RFC1001_PORT))
2430 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00002431
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 return rc;
2433}
2434
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002435static int
2436ip_connect(struct TCP_Server_Info *server)
2437{
Steve French6da97912011-03-13 18:55:55 +00002438 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002439 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2440 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2441
2442 if (server->dstaddr.ss_family == AF_INET6)
2443 sport = &addr6->sin6_port;
2444 else
2445 sport = &addr->sin_port;
2446
2447 if (*sport == 0) {
2448 int rc;
2449
2450 /* try with 445 port at first */
2451 *sport = htons(CIFS_PORT);
2452
2453 rc = generic_ip_connect(server);
2454 if (rc >= 0)
2455 return rc;
2456
2457 /* if it failed, try with 139 port */
2458 *sport = htons(RFC1001_PORT);
2459 }
2460
2461 return generic_ip_connect(server);
2462}
2463
Steve French50c2f752007-07-13 00:33:32 +00002464void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2465 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00002466{
2467 /* if we are reconnecting then should we check to see if
2468 * any requested capabilities changed locally e.g. via
2469 * remount but we can not do much about it here
2470 * if they have (even if we could detect it by the following)
2471 * Perhaps we could add a backpointer to array of sb from tcon
2472 * or if we change to make all sb to same share the same
2473 * sb as NFS - then we only have one backpointer to sb.
2474 * What if we wanted to mount the server share twice once with
2475 * and once without posixacls or posix paths? */
2476 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002477
Steve Frenchc18c8422007-07-18 23:21:09 +00002478 if (vol_info && vol_info->no_linux_ext) {
2479 tcon->fsUnixInfo.Capability = 0;
2480 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002481 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00002482 return;
2483 } else if (vol_info)
2484 tcon->unix_ext = 1; /* Unix Extensions supported */
2485
2486 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002487 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00002488 return;
2489 }
Steve French50c2f752007-07-13 00:33:32 +00002490
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002491 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00002492 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002493
Steve French8af18972007-02-14 04:42:51 +00002494 /* check for reconnect case in which we do not
2495 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002496 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002497 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002498 originally at mount time */
2499 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2500 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002501 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2502 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002503 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00002504 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002505 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002506 cERROR(1, "possible reconnect error");
2507 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00002508 }
Steve French8af18972007-02-14 04:42:51 +00002509 }
Steve French50c2f752007-07-13 00:33:32 +00002510
Steve French8af18972007-02-14 04:42:51 +00002511 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002512 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002513 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002514 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002515 cFYI(1, "negotiated posix acl support");
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002516 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002517 sb->s_flags |= MS_POSIXACL;
2518 }
2519
Steve French75865f8c2007-06-24 18:30:48 +00002520 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002521 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002522 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002523 cFYI(1, "negotiate posix pathnames");
Steve French75865f8c2007-06-24 18:30:48 +00002524 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002525 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002526 CIFS_MOUNT_POSIX_PATHS;
2527 }
Steve French50c2f752007-07-13 00:33:32 +00002528
Steve French984acfe2007-04-26 16:42:50 +00002529 /* We might be setting the path sep back to a different
2530 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002531 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002532 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002533 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002534
2535 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2536 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2537 CIFS_SB(sb)->rsize = 127 * 1024;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002538 cFYI(DBG2, "larger reads not supported by srv");
Steve French75865f8c2007-06-24 18:30:48 +00002539 }
2540 }
Steve French50c2f752007-07-13 00:33:32 +00002541
2542
Joe Perchesb6b38f72010-04-21 03:50:45 +00002543 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00002544#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002545 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002546 cFYI(1, "FCNTL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002547 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002548 cFYI(1, "EXTATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002549 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002550 cFYI(1, "POSIX path cap");
Steve French75865f8c2007-06-24 18:30:48 +00002551 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002552 cFYI(1, "XATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002553 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002554 cFYI(1, "POSIX ACL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002555 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002556 cFYI(1, "very large read cap");
Steve French75865f8c2007-06-24 18:30:48 +00002557 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002558 cFYI(1, "very large write cap");
Steve French8af18972007-02-14 04:42:51 +00002559#endif /* CIFS_DEBUG2 */
2560 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002561 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002562 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00002563 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002564 cERROR(1, "Negotiating Unix capabilities "
Steve French5a44b312007-09-20 15:16:24 +00002565 "with the server failed. Consider "
2566 "mounting with the Unix Extensions\n"
2567 "disabled, if problems are found, "
2568 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00002569 "option.");
Steve French5a44b312007-09-20 15:16:24 +00002570
Steve French8af18972007-02-14 04:42:51 +00002571 }
2572 }
2573}
2574
Steve French03a143c2008-02-14 06:38:30 +00002575static void
2576convert_delimiter(char *path, char delim)
2577{
2578 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002579 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002580
2581 if (path == NULL)
2582 return;
2583
Steve French582d21e2008-05-13 04:54:12 +00002584 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002585 old_delim = '\\';
2586 else
2587 old_delim = '/';
2588
Steve French03a143c2008-02-14 06:38:30 +00002589 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002590 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002591 path[i] = delim;
2592 }
2593}
2594
Steve French3b795212008-11-13 19:45:32 +00002595static void setup_cifs_sb(struct smb_vol *pvolume_info,
2596 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002597{
Jeff Layton2de970f2010-10-06 19:51:12 -04002598 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2599
Steve French3b795212008-11-13 19:45:32 +00002600 if (pvolume_info->rsize > CIFSMaxBufSize) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002601 cERROR(1, "rsize %d too large, using MaxBufSize",
2602 pvolume_info->rsize);
Steve French3b795212008-11-13 19:45:32 +00002603 cifs_sb->rsize = CIFSMaxBufSize;
2604 } else if ((pvolume_info->rsize) &&
2605 (pvolume_info->rsize <= CIFSMaxBufSize))
2606 cifs_sb->rsize = pvolume_info->rsize;
2607 else /* default */
2608 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002609
Steve French3b795212008-11-13 19:45:32 +00002610 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002611 cERROR(1, "wsize %d too large, using 4096 instead",
2612 pvolume_info->wsize);
Steve French3b795212008-11-13 19:45:32 +00002613 cifs_sb->wsize = 4096;
2614 } else if (pvolume_info->wsize)
2615 cifs_sb->wsize = pvolume_info->wsize;
2616 else
2617 cifs_sb->wsize = min_t(const int,
2618 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2619 127*1024);
2620 /* old default of CIFSMaxBufSize was too small now
2621 that SMB Write2 can send multiple pages in kvec.
2622 RFC1001 does not describe what happens when frame
2623 bigger than 128K is sent so use that as max in
2624 conjunction with 52K kvec constraint on arch with 4K
2625 page size */
2626
2627 if (cifs_sb->rsize < 2048) {
2628 cifs_sb->rsize = 2048;
2629 /* Windows ME may prefer this */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002630 cFYI(1, "readsize set to minimum: 2048");
Steve French3b795212008-11-13 19:45:32 +00002631 }
2632 /* calculate prepath */
2633 cifs_sb->prepath = pvolume_info->prepath;
2634 if (cifs_sb->prepath) {
2635 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2636 /* we can not convert the / to \ in the path
2637 separators in the prefixpath yet because we do not
2638 know (until reset_cifs_unix_caps is called later)
2639 whether POSIX PATH CAP is available. We normalize
2640 the / to \ after reset_cifs_unix_caps is called */
2641 pvolume_info->prepath = NULL;
2642 } else
2643 cifs_sb->prepathlen = 0;
2644 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2645 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2646 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2647 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002648 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2649 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00002650
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302651 cifs_sb->actimeo = pvolume_info->actimeo;
2652
Steve French3b795212008-11-13 19:45:32 +00002653 if (pvolume_info->noperm)
2654 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2655 if (pvolume_info->setuids)
2656 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2657 if (pvolume_info->server_ino)
2658 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2659 if (pvolume_info->remap)
2660 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2661 if (pvolume_info->no_xattr)
2662 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2663 if (pvolume_info->sfu_emul)
2664 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2665 if (pvolume_info->nobrl)
2666 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002667 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002668 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002669 if (pvolume_info->mand_lock)
2670 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002671 if (pvolume_info->cifs_acl)
2672 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2673 if (pvolume_info->override_uid)
2674 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2675 if (pvolume_info->override_gid)
2676 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2677 if (pvolume_info->dynperm)
2678 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05302679 if (pvolume_info->fsc)
2680 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04002681 if (pvolume_info->multiuser)
2682 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2683 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05002684 if (pvolume_info->strict_io)
2685 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00002686 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002687 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00002688 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2689 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02002690 if (pvolume_info->mfsymlinks) {
2691 if (pvolume_info->sfu_emul) {
2692 cERROR(1, "mount option mfsymlinks ignored if sfu "
2693 "mount option is used");
2694 } else {
2695 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2696 }
2697 }
Steve French3b795212008-11-13 19:45:32 +00002698
2699 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00002700 cERROR(1, "mount option dynperm ignored if cifsacl "
2701 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002702}
2703
Igor Mammedove4cce942009-02-10 14:10:26 +03002704static int
2705is_path_accessible(int xid, struct cifsTconInfo *tcon,
2706 struct cifs_sb_info *cifs_sb, const char *full_path)
2707{
2708 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03002709 FILE_ALL_INFO *pfile_info;
2710
Igor Mammedove4cce942009-02-10 14:10:26 +03002711 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2712 if (pfile_info == NULL)
2713 return -ENOMEM;
2714
2715 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2716 0 /* not legacy */, cifs_sb->local_nls,
2717 cifs_sb->mnt_cifs_flags &
2718 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton221d1d72011-05-17 06:40:30 -04002719
2720 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2721 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2722 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2723 CIFS_MOUNT_MAP_SPECIAL_CHR);
Igor Mammedove4cce942009-02-10 14:10:26 +03002724 kfree(pfile_info);
2725 return rc;
2726}
2727
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002728static void
2729cleanup_volume_info(struct smb_vol **pvolume_info)
2730{
2731 struct smb_vol *volume_info;
2732
Dan Carpenterad6cca62010-04-26 12:10:06 +02002733 if (!pvolume_info || !*pvolume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002734 return;
2735
2736 volume_info = *pvolume_info;
Sean Finneyb9468452011-04-11 13:19:32 +00002737 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002738 kzfree(volume_info->password);
2739 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00002740 kfree(volume_info->UNCip);
2741 kfree(volume_info->domainname);
2742 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002743 kfree(volume_info->prepath);
2744 kfree(volume_info);
2745 *pvolume_info = NULL;
2746 return;
2747}
2748
Steve French2d6d5892009-04-09 00:36:44 +00002749#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002750/* build_path_to_root returns full path to root when
2751 * we do not have an exiting connection (tcon) */
2752static char *
2753build_unc_path_to_root(const struct smb_vol *volume_info,
2754 const struct cifs_sb_info *cifs_sb)
2755{
2756 char *full_path;
2757
2758 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2759 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2760 if (full_path == NULL)
2761 return ERR_PTR(-ENOMEM);
2762
2763 strncpy(full_path, volume_info->UNC, unc_len);
2764 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2765 int i;
2766 for (i = 0; i < unc_len; i++) {
2767 if (full_path[i] == '\\')
2768 full_path[i] = '/';
2769 }
2770 }
2771
2772 if (cifs_sb->prepathlen)
2773 strncpy(full_path + unc_len, cifs_sb->prepath,
2774 cifs_sb->prepathlen);
2775
2776 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2777 return full_path;
2778}
Sean Finneydd613942011-04-11 13:19:30 +00002779
2780/*
2781 * Perform a dfs referral query for a share and (optionally) prefix
2782 *
Sean Finney046462a2011-04-11 13:19:33 +00002783 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2784 * to a string containing updated options for the submount. Otherwise it
2785 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00002786 *
2787 * Returns the rc from get_dfs_path to the caller, which can be used to
2788 * determine whether there were referrals.
2789 */
2790static int
2791expand_dfs_referral(int xid, struct cifsSesInfo *pSesInfo,
2792 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00002793 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00002794{
2795 int rc;
2796 unsigned int num_referrals = 0;
2797 struct dfs_info3_param *referrals = NULL;
2798 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2799
2800 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2801 if (IS_ERR(full_path))
2802 return PTR_ERR(full_path);
2803
2804 /* For DFS paths, skip the first '\' of the UNC */
2805 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2806
2807 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2808 &num_referrals, &referrals,
2809 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2810
2811 if (!rc && num_referrals > 0) {
2812 char *fake_devname = NULL;
2813
2814 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2815 full_path + 1, referrals,
2816 &fake_devname);
2817
2818 free_dfs_info_array(referrals, num_referrals);
2819 kfree(fake_devname);
2820
Sean Finney046462a2011-04-11 13:19:33 +00002821 if (cifs_sb->mountdata != NULL)
2822 kfree(cifs_sb->mountdata);
2823
Sean Finneydd613942011-04-11 13:19:30 +00002824 if (IS_ERR(mdata)) {
2825 rc = PTR_ERR(mdata);
2826 mdata = NULL;
2827 }
Sean Finney046462a2011-04-11 13:19:33 +00002828 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00002829 }
2830 kfree(full_path);
2831 return rc;
2832}
Steve French2d6d5892009-04-09 00:36:44 +00002833#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002834
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835int
2836cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Sean Finneyf14bcf72011-04-11 13:19:35 +00002837 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838{
Jeff Laytona2934c72009-12-03 08:09:41 -05002839 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002841 struct smb_vol *volume_info;
Jeff Laytona2934c72009-12-03 08:09:41 -05002842 struct cifsSesInfo *pSesInfo;
2843 struct cifsTconInfo *tcon;
2844 struct TCP_Server_Info *srvTcp;
Igor Mammedove4cce942009-02-10 14:10:26 +03002845 char *full_path;
Jeff Layton9d002df2010-10-06 19:51:11 -04002846 struct tcon_link *tlink;
Steve French2d6d5892009-04-09 00:36:44 +00002847#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002848 int referral_walks_count = 0;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002849try_mount_again:
Sean Finneydd613942011-04-11 13:19:30 +00002850 /* cleanup activities if we're chasing a referral */
2851 if (referral_walks_count) {
2852 if (tcon)
2853 cifs_put_tcon(tcon);
2854 else if (pSesInfo)
2855 cifs_put_smb_ses(pSesInfo);
2856
2857 cleanup_volume_info(&volume_info);
2858 FreeXid(xid);
2859 }
Steve French2d6d5892009-04-09 00:36:44 +00002860#endif
Jeff Laytona2934c72009-12-03 08:09:41 -05002861 rc = 0;
2862 tcon = NULL;
2863 pSesInfo = NULL;
2864 srvTcp = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002865 full_path = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04002866 tlink = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867
2868 xid = GetXid();
2869
Jeff Layton7586b762008-12-01 18:41:49 -05002870 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2871 if (!volume_info) {
2872 rc = -ENOMEM;
2873 goto out;
2874 }
Steve French50c2f752007-07-13 00:33:32 +00002875
Sean Finneyf14bcf72011-04-11 13:19:35 +00002876 if (cifs_parse_mount_options(cifs_sb->mountdata, devname,
2877 volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002878 rc = -EINVAL;
2879 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 }
2881
Jeff Layton7586b762008-12-01 18:41:49 -05002882 if (volume_info->nullauth) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002883 cFYI(1, "null user");
Jeff Layton7586b762008-12-01 18:41:49 -05002884 volume_info->username = "";
2885 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002887 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002889 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002890 /* In userspace mount helper we can get user name from alternate
2891 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002892 rc = -EINVAL;
2893 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 }
2895
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002897 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002898 /* load_nls_default cannot return null */
2899 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002901 volume_info->local_nls = load_nls(volume_info->iocharset);
2902 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002903 cERROR(1, "CIFS mount error: iocharset %s not found",
2904 volume_info->iocharset);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002905 rc = -ELIBACC;
2906 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907 }
2908 }
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002909 cifs_sb->local_nls = volume_info->local_nls;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910
Jeff Layton63c038c2008-12-01 18:41:46 -05002911 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002912 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002913 if (IS_ERR(srvTcp)) {
2914 rc = PTR_ERR(srvTcp);
2915 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 }
2917
Jeff Layton36988c72010-04-24 07:57:43 -04002918 /* get a reference to a SMB session */
2919 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2920 if (IS_ERR(pSesInfo)) {
2921 rc = PTR_ERR(pSesInfo);
2922 pSesInfo = NULL;
2923 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 }
Steve French50c2f752007-07-13 00:33:32 +00002925
Jeff Laytond00c28d2010-04-24 07:57:44 -04002926 setup_cifs_sb(volume_info, cifs_sb);
2927 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2928 sb->s_maxbytes = MAX_LFS_FILESIZE;
2929 else
2930 sb->s_maxbytes = MAX_NON_LFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931
Steve French8af18972007-02-14 04:42:51 +00002932 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 sb->s_time_gran = 100;
2934
Jeff Laytond00c28d2010-04-24 07:57:44 -04002935 /* search for existing tcon to this server share */
2936 tcon = cifs_get_tcon(pSesInfo, volume_info);
2937 if (IS_ERR(tcon)) {
2938 rc = PTR_ERR(tcon);
2939 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002940 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002941 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002942
Steve Frenchd82c2df2008-11-15 00:07:26 +00002943 /* do not care if following two calls succeed - informational */
2944 if (!tcon->ipc) {
2945 CIFSSMBQFSDeviceInfo(xid, tcon);
2946 CIFSSMBQFSAttributeInfo(xid, tcon);
2947 }
2948
2949 /* tell server which Unix caps we support */
2950 if (tcon->ses->capabilities & CAP_UNIX)
2951 /* reset of caps checks mount to see if unix extensions
2952 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002953 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002954 else
2955 tcon->unix_ext = 0; /* server does not support them */
2956
2957 /* convert forward to back slashes in prepath here if needed */
2958 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2959 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2960
2961 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2962 cifs_sb->rsize = 1024 * 127;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002963 cFYI(DBG2, "no very large read support, rsize now 127K");
Steve Frenchd82c2df2008-11-15 00:07:26 +00002964 }
2965 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2966 cifs_sb->wsize = min(cifs_sb->wsize,
2967 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2968 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2969 cifs_sb->rsize = min(cifs_sb->rsize,
2970 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002972remote_path_check:
Sean Finneyc1508ca2011-04-11 13:19:31 +00002973#ifdef CONFIG_CIFS_DFS_UPCALL
2974 /*
2975 * Perform an unconditional check for whether there are DFS
2976 * referrals for this path without prefix, to provide support
2977 * for DFS referrals from w2k8 servers which don't seem to respond
2978 * with PATH_NOT_COVERED to requests that include the prefix.
2979 * Chase the referral if found, otherwise continue normally.
2980 */
2981 if (referral_walks_count == 0) {
2982 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
Sean Finney046462a2011-04-11 13:19:33 +00002983 cifs_sb, false);
Sean Finneyc1508ca2011-04-11 13:19:31 +00002984 if (!refrc) {
2985 referral_walks_count++;
2986 goto try_mount_again;
2987 }
2988 }
2989#endif
2990
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002991 /* check if a whole path (including prepath) is not remote */
Jeff Layton70945642011-03-14 13:48:08 -04002992 if (!rc && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002993 /* build_path_to_root works only when we have a valid tcon */
Jeff Layton7d161b72010-12-07 02:10:35 -05002994 full_path = cifs_build_path_to_root(cifs_sb, tcon);
Igor Mammedove4cce942009-02-10 14:10:26 +03002995 if (full_path == NULL) {
2996 rc = -ENOMEM;
2997 goto mount_fail_check;
2998 }
2999 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Jeff Layton03ceace2010-12-06 21:07:33 -05003000 if (rc != 0 && rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03003001 kfree(full_path);
3002 goto mount_fail_check;
3003 }
3004 kfree(full_path);
3005 }
3006
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003007 /* get referral if needed */
3008 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00003009#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003010 if (referral_walks_count > MAX_NESTED_LINKS) {
3011 /*
3012 * BB: when we implement proper loop detection,
3013 * we will remove this check. But now we need it
3014 * to prevent an indefinite loop if 'DFS tree' is
3015 * misconfigured (i.e. has loops).
3016 */
3017 rc = -ELOOP;
3018 goto mount_fail_check;
3019 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003020 /* convert forward to back slashes in prepath here if needed */
3021 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
3022 convert_delimiter(cifs_sb->prepath,
3023 CIFS_DIR_SEP(cifs_sb));
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003024
Sean Finneydd613942011-04-11 13:19:30 +00003025 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003026 true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003027
Sean Finneydd613942011-04-11 13:19:30 +00003028 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003029 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003030 goto try_mount_again;
3031 }
Sean Finneydd613942011-04-11 13:19:30 +00003032 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003033#else /* No DFS support, return error on mount */
3034 rc = -EOPNOTSUPP;
3035#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003036 }
3037
Jeff Layton9d002df2010-10-06 19:51:11 -04003038 if (rc)
3039 goto mount_fail_check;
3040
3041 /* now, hang the tcon off of the superblock */
3042 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3043 if (tlink == NULL) {
3044 rc = -ENOMEM;
3045 goto mount_fail_check;
3046 }
3047
Jeff Laytonb647c352010-10-28 11:16:44 -04003048 tlink->tl_uid = pSesInfo->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003049 tlink->tl_tcon = tcon;
3050 tlink->tl_time = jiffies;
3051 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3052 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3053
Jeff Layton413e6612010-10-28 13:33:38 -04003054 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003055 spin_lock(&cifs_sb->tlink_tree_lock);
3056 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3057 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003058
Jeff Layton2de970f2010-10-06 19:51:12 -04003059 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3060 TLINK_IDLE_EXPIRE);
3061
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003062mount_fail_check:
3063 /* on error free sesinfo and tcon struct if needed */
3064 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003065 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003066 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003067 if (tcon)
3068 cifs_put_tcon(tcon);
3069 else if (pSesInfo)
3070 cifs_put_smb_ses(pSesInfo);
3071 else
3072 cifs_put_tcp_session(srvTcp);
3073 goto out;
3074 }
3075
Jeff Layton7586b762008-12-01 18:41:49 -05003076 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077 (in which case it is not needed anymore) but when new sesion is created
3078 the password ptr is put in the new session structure (in which case the
3079 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00003080out:
3081 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003082 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 FreeXid(xid);
3084 return rc;
3085}
3086
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087int
3088CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3089 const char *tree, struct cifsTconInfo *tcon,
3090 const struct nls_table *nls_codepage)
3091{
3092 struct smb_hdr *smb_buffer;
3093 struct smb_hdr *smb_buffer_response;
3094 TCONX_REQ *pSMB;
3095 TCONX_RSP *pSMBr;
3096 unsigned char *bcc_ptr;
3097 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003098 int length;
3099 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100
3101 if (ses == NULL)
3102 return -EIO;
3103
3104 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003105 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003107
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 smb_buffer_response = smb_buffer;
3109
3110 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3111 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003112
3113 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 smb_buffer->Uid = ses->Suid;
3115 pSMB = (TCONX_REQ *) smb_buffer;
3116 pSMBr = (TCONX_RSP *) smb_buffer_response;
3117
3118 pSMB->AndXCommand = 0xFF;
3119 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003120 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003121 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08003122 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003123 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003124 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003125 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003126 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003127 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003128 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3129 specified as required (when that support is added to
3130 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003131 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003132 by Samba (not sure whether other servers allow
3133 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003134#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003135 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003136 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003137 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003138 ses->server->secMode &
3139 SECMODE_PW_ENCRYPT ? true : false,
3140 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003141 else
3142#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003143 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3144 bcc_ptr);
Steve Frencheeac8042006-01-13 21:34:58 -08003145
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003146 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003147 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003148 /* must align unicode strings */
3149 *bcc_ptr = 0; /* null byte password */
3150 bcc_ptr++;
3151 }
Steve Frencheeac8042006-01-13 21:34:58 -08003152 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153
Steve French50c2f752007-07-13 00:33:32 +00003154 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003155 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3157
3158 if (ses->capabilities & CAP_STATUS32) {
3159 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3160 }
3161 if (ses->capabilities & CAP_DFS) {
3162 smb_buffer->Flags2 |= SMBFLG2_DFS;
3163 }
3164 if (ses->capabilities & CAP_UNICODE) {
3165 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3166 length =
Steve French50c2f752007-07-13 00:33:32 +00003167 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3168 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003169 (/* server len*/ + 256 /* share len */), nls_codepage);
3170 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 bcc_ptr += 2; /* skip trailing null */
3172 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003173 strcpy(bcc_ptr, tree);
3174 bcc_ptr += strlen(tree) + 1;
3175 }
3176 strcpy(bcc_ptr, "?????");
3177 bcc_ptr += strlen("?????");
3178 bcc_ptr += 1;
3179 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003180 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3181 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 pSMB->ByteCount = cpu_to_le16(count);
3183
Steve French133672e2007-11-13 22:41:37 +00003184 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003185 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 /* above now done in SendReceive */
3188 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003189 bool is_unicode;
3190
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003192 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 tcon->tid = smb_buffer_response->Tid;
3194 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003195 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003196 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003197 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3198 is_unicode = true;
3199 else
3200 is_unicode = false;
3201
Jeff Laytoncc20c032009-04-30 07:16:21 -04003202
Steve French50c2f752007-07-13 00:33:32 +00003203 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003204 if (length == 3) {
3205 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3206 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003207 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003208 tcon->ipc = 1;
3209 }
3210 } else if (length == 2) {
3211 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3212 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003213 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003214 }
3215 }
Steve French50c2f752007-07-13 00:33:32 +00003216 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003217 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003219
3220 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003221 kfree(tcon->nativeFileSystem);
Steve Frenchd185cda2009-04-30 17:45:10 +00003222 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003223 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003224 nls_codepage);
3225
Joe Perchesb6b38f72010-04-21 03:50:45 +00003226 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003227
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003228 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003229 (smb_buffer_response->WordCount == 7))
3230 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003231 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3232 else
3233 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003234 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003236 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 ses->ipc_tid = smb_buffer_response->Tid;
3238 }
3239
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003240 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241 return rc;
3242}
3243
3244int
3245cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3246{
Jeff Laytonb647c352010-10-28 11:16:44 -04003247 struct rb_root *root = &cifs_sb->tlink_tree;
3248 struct rb_node *node;
3249 struct tcon_link *tlink;
Steve French50c2f752007-07-13 00:33:32 +00003250 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251
Jeff Layton2de970f2010-10-06 19:51:12 -04003252 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3253
Jeff Laytonb647c352010-10-28 11:16:44 -04003254 spin_lock(&cifs_sb->tlink_tree_lock);
3255 while ((node = rb_first(root))) {
3256 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3257 cifs_get_tlink(tlink);
3258 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3259 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003260
Jeff Laytonb647c352010-10-28 11:16:44 -04003261 spin_unlock(&cifs_sb->tlink_tree_lock);
3262 cifs_put_tlink(tlink);
3263 spin_lock(&cifs_sb->tlink_tree_lock);
3264 }
3265 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003266
Steve French2fe87f02006-09-21 07:02:52 +00003267 tmp = cifs_sb->prepath;
3268 cifs_sb->prepathlen = 0;
3269 cifs_sb->prepath = NULL;
3270 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271
Jeff Layton9d002df2010-10-06 19:51:11 -04003272 return 0;
Steve French50c2f752007-07-13 00:33:32 +00003273}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274
Jeff Layton198b5682010-04-24 07:57:48 -04003275int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276{
3277 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003278 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279
Jeff Layton198b5682010-04-24 07:57:48 -04003280 /* only send once per connect */
3281 if (server->maxBuf != 0)
3282 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003283
Jeff Layton198b5682010-04-24 07:57:48 -04003284 rc = CIFSSMBNegotiate(xid, ses);
3285 if (rc == -EAGAIN) {
3286 /* retry only once on 1st time connection */
3287 rc = CIFSSMBNegotiate(xid, ses);
3288 if (rc == -EAGAIN)
3289 rc = -EHOSTDOWN;
3290 }
3291 if (rc == 0) {
3292 spin_lock(&GlobalMid_Lock);
3293 if (server->tcpStatus != CifsExiting)
3294 server->tcpStatus = CifsGood;
3295 else
3296 rc = -EHOSTDOWN;
3297 spin_unlock(&GlobalMid_Lock);
3298
Linus Torvalds1da177e2005-04-16 15:20:36 -07003299 }
Steve French26b994f2008-08-06 05:11:33 +00003300
Jeff Layton198b5682010-04-24 07:57:48 -04003301 return rc;
3302}
Steve French26b994f2008-08-06 05:11:33 +00003303
Jeff Layton198b5682010-04-24 07:57:48 -04003304
3305int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3306 struct nls_table *nls_info)
3307{
3308 int rc = 0;
3309 struct TCP_Server_Info *server = ses->server;
3310
3311 ses->flags = 0;
3312 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003313 if (linuxExtEnabled == 0)
Jeff Layton198b5682010-04-24 07:57:48 -04003314 ses->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00003315
Joe Perchesb6b38f72010-04-21 03:50:45 +00003316 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3317 server->secMode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003318
Jeff Layton198b5682010-04-24 07:57:48 -04003319 rc = CIFS_SessSetup(xid, ses, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00003320 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003321 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00003322 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003323 mutex_lock(&ses->server->srv_mutex);
3324 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003325 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003326 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003327 server->sequence_number = 0x2;
3328 server->session_estab = true;
3329 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003330 }
3331 mutex_unlock(&server->srv_mutex);
3332
Joe Perchesb6b38f72010-04-21 03:50:45 +00003333 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00003334 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003335 ses->status = CifsGood;
3336 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003337 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003338 }
3339
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003340 kfree(ses->auth_key.response);
3341 ses->auth_key.response = NULL;
3342 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003343 kfree(ses->ntlmssp);
3344 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003345
Linus Torvalds1da177e2005-04-16 15:20:36 -07003346 return rc;
3347}
3348
Steve Frenchd2445552010-10-08 03:38:46 +00003349static struct cifsTconInfo *
Jeff Layton9d002df2010-10-06 19:51:11 -04003350cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3351{
3352 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3353 struct cifsSesInfo *ses;
3354 struct cifsTconInfo *tcon = NULL;
3355 struct smb_vol *vol_info;
Steve French34c87902011-03-01 05:02:57 +00003356 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3357 /* We used to have this as MAX_USERNAME which is */
3358 /* way too big now (256 instead of 32) */
Jeff Layton9d002df2010-10-06 19:51:11 -04003359
3360 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3361 if (vol_info == NULL) {
3362 tcon = ERR_PTR(-ENOMEM);
3363 goto out;
3364 }
3365
3366 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3367 vol_info->username = username;
3368 vol_info->local_nls = cifs_sb->local_nls;
3369 vol_info->linux_uid = fsuid;
3370 vol_info->cred_uid = fsuid;
3371 vol_info->UNC = master_tcon->treeName;
3372 vol_info->retry = master_tcon->retry;
3373 vol_info->nocase = master_tcon->nocase;
3374 vol_info->local_lease = master_tcon->local_lease;
3375 vol_info->no_linux_ext = !master_tcon->unix_ext;
3376
3377 /* FIXME: allow for other secFlg settings */
3378 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3379
3380 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303381 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003382 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303383 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003384
3385 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3386 if (IS_ERR(ses)) {
3387 tcon = (struct cifsTconInfo *)ses;
3388 cifs_put_tcp_session(master_tcon->ses->server);
3389 goto out;
3390 }
3391
3392 tcon = cifs_get_tcon(ses, vol_info);
3393 if (IS_ERR(tcon)) {
3394 cifs_put_smb_ses(ses);
3395 goto out;
3396 }
3397
3398 if (ses->capabilities & CAP_UNIX)
3399 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3400out:
3401 kfree(vol_info);
3402
3403 return tcon;
3404}
3405
Jeff Layton413e6612010-10-28 13:33:38 -04003406static inline struct tcon_link *
Jeff Layton9d002df2010-10-06 19:51:11 -04003407cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3408{
Jeff Layton413e6612010-10-28 13:33:38 -04003409 return cifs_sb->master_tlink;
Jeff Layton9d002df2010-10-06 19:51:11 -04003410}
3411
3412struct cifsTconInfo *
3413cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3414{
3415 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3416}
3417
3418static int
3419cifs_sb_tcon_pending_wait(void *unused)
3420{
3421 schedule();
3422 return signal_pending(current) ? -ERESTARTSYS : 0;
3423}
3424
Jeff Laytonb647c352010-10-28 11:16:44 -04003425/* find and return a tlink with given uid */
3426static struct tcon_link *
3427tlink_rb_search(struct rb_root *root, uid_t uid)
3428{
3429 struct rb_node *node = root->rb_node;
3430 struct tcon_link *tlink;
3431
3432 while (node) {
3433 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3434
3435 if (tlink->tl_uid > uid)
3436 node = node->rb_left;
3437 else if (tlink->tl_uid < uid)
3438 node = node->rb_right;
3439 else
3440 return tlink;
3441 }
3442 return NULL;
3443}
3444
3445/* insert a tcon_link into the tree */
3446static void
3447tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3448{
3449 struct rb_node **new = &(root->rb_node), *parent = NULL;
3450 struct tcon_link *tlink;
3451
3452 while (*new) {
3453 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3454 parent = *new;
3455
3456 if (tlink->tl_uid > new_tlink->tl_uid)
3457 new = &((*new)->rb_left);
3458 else
3459 new = &((*new)->rb_right);
3460 }
3461
3462 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3463 rb_insert_color(&new_tlink->tl_rbnode, root);
3464}
3465
Jeff Layton9d002df2010-10-06 19:51:11 -04003466/*
3467 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3468 * current task.
3469 *
3470 * If the superblock doesn't refer to a multiuser mount, then just return
3471 * the master tcon for the mount.
3472 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05303473 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04003474 * exists, then check to see if it's pending construction. If it is then wait
3475 * for construction to complete. Once it's no longer pending, check to see if
3476 * it failed and either return an error or retry construction, depending on
3477 * the timeout.
3478 *
3479 * If one doesn't exist then insert a new tcon_link struct into the tree and
3480 * try to construct a new one.
3481 */
3482struct tcon_link *
3483cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3484{
3485 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04003486 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04003487 struct tcon_link *tlink, *newtlink;
3488
3489 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3490 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3491
3492 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003493 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003494 if (tlink)
3495 cifs_get_tlink(tlink);
3496 spin_unlock(&cifs_sb->tlink_tree_lock);
3497
3498 if (tlink == NULL) {
3499 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3500 if (newtlink == NULL)
3501 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04003502 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003503 newtlink->tl_tcon = ERR_PTR(-EACCES);
3504 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3505 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3506 cifs_get_tlink(newtlink);
3507
Jeff Layton9d002df2010-10-06 19:51:11 -04003508 spin_lock(&cifs_sb->tlink_tree_lock);
3509 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04003510 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003511 if (tlink) {
3512 cifs_get_tlink(tlink);
3513 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003514 kfree(newtlink);
3515 goto wait_for_construction;
3516 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003517 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003518 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3519 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003520 } else {
3521wait_for_construction:
3522 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3523 cifs_sb_tcon_pending_wait,
3524 TASK_INTERRUPTIBLE);
3525 if (ret) {
3526 cifs_put_tlink(tlink);
3527 return ERR_PTR(ret);
3528 }
3529
3530 /* if it's good, return it */
3531 if (!IS_ERR(tlink->tl_tcon))
3532 return tlink;
3533
3534 /* return error if we tried this already recently */
3535 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3536 cifs_put_tlink(tlink);
3537 return ERR_PTR(-EACCES);
3538 }
3539
3540 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3541 goto wait_for_construction;
3542 }
3543
3544 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3545 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3546 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3547
3548 if (IS_ERR(tlink->tl_tcon)) {
3549 cifs_put_tlink(tlink);
3550 return ERR_PTR(-EACCES);
3551 }
3552
3553 return tlink;
3554}
Jeff Layton2de970f2010-10-06 19:51:12 -04003555
3556/*
3557 * periodic workqueue job that scans tcon_tree for a superblock and closes
3558 * out tcons.
3559 */
3560static void
3561cifs_prune_tlinks(struct work_struct *work)
3562{
3563 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3564 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04003565 struct rb_root *root = &cifs_sb->tlink_tree;
3566 struct rb_node *node = rb_first(root);
3567 struct rb_node *tmp;
3568 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04003569
Jeff Laytonb647c352010-10-28 11:16:44 -04003570 /*
3571 * Because we drop the spinlock in the loop in order to put the tlink
3572 * it's not guarded against removal of links from the tree. The only
3573 * places that remove entries from the tree are this function and
3574 * umounts. Because this function is non-reentrant and is canceled
3575 * before umount can proceed, this is safe.
3576 */
3577 spin_lock(&cifs_sb->tlink_tree_lock);
3578 node = rb_first(root);
3579 while (node != NULL) {
3580 tmp = node;
3581 node = rb_next(tmp);
3582 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3583
3584 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3585 atomic_read(&tlink->tl_count) != 0 ||
3586 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3587 continue;
3588
3589 cifs_get_tlink(tlink);
3590 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3591 rb_erase(tmp, root);
3592
Jeff Layton2de970f2010-10-06 19:51:12 -04003593 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003594 cifs_put_tlink(tlink);
3595 spin_lock(&cifs_sb->tlink_tree_lock);
3596 }
3597 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04003598
3599 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3600 TLINK_IDLE_EXPIRE);
3601}