blob: cc1a8604a790b46767e066a59ef897f314144163 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070055extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
56 unsigned char *p24);
57
58extern 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 */
67 char source_rfc1001_name[16]; /* netbios name of client */
Steve Frencha10faeb22005-08-22 21:38:31 -070068 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
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;
Steve French95b1cb92008-05-15 16:44:38 +000087 bool remap:1; /* set to remap seven reserved chars in filenames */
88 bool posix_paths:1; /* unset to not ask for posix pathnames. */
Steve French4b18f2a2008-04-29 00:06:05 +000089 bool no_linux_ext:1;
90 bool sfu_emul:1;
Steve French95b1cb92008-05-15 16:44:38 +000091 bool nullauth:1; /* attempt to authenticate with null user */
92 bool nocase:1; /* request case insensitive filenames */
93 bool nobrl:1; /* disable sending byte range locks to srv */
Steve French13a6e422008-12-02 17:24:33 +000094 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
Steve French95b1cb92008-05-15 16:44:38 +000095 bool seal:1; /* request transport encryption on share */
Steve French84210e92008-10-23 04:42:37 +000096 bool nodfs:1; /* Do not request DFS, even if available */
97 bool local_lease:1; /* check leases only on local system, not remote */
Steve Frenchedf1ae42008-10-29 00:47:57 +000098 bool noblocksnd:1;
99 bool noautotune:1;
Steve Frenchbe652442009-02-23 15:21:59 +0000100 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
Suresh Jayaramanfa1df752010-07-05 18:13:36 +0530101 bool fsc:1; /* enable fscache */
Stefan Metzmacher736a3322010-07-30 14:56:00 +0200102 bool mfsymlinks:1; /* use Minshall+French Symlinks */
Jeff Layton0eb8a132010-10-06 19:51:12 -0400103 bool multiuser:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 unsigned int rsize;
105 unsigned int wsize;
Steve French6a5fa2362010-01-01 01:28:43 +0000106 bool sockopt_tcp_nodelay:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 unsigned short int port;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530108 unsigned long actimeo; /* attribute cache timeout (jiffies) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000109 char *prepath;
Ben Greear3eb9a882010-09-01 17:06:02 -0700110 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
Jeff Laytona5fc4ce2010-04-24 07:57:42 -0400111 struct nls_table *local_nls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112};
113
Jeff Layton2de970f2010-10-06 19:51:12 -0400114/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -0400115#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -0400116#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -0400117
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500118static int ipv4_connect(struct TCP_Server_Info *server);
Jeff Laytond5c56052008-12-01 18:42:33 -0500119static int ipv6_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400120static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400121static void cifs_prune_tlinks(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Jeff Laytond5c56052008-12-01 18:42:33 -0500123/*
124 * cifs tcp session reconnection
125 *
126 * mark tcp session as reconnecting so temporarily locked
127 * mark all smb sessions as reconnecting for tcp session
128 * reconnect tcp session
129 * wake up waiters on reconnection? - (not needed currently)
130 */
Steve French2cd646a2006-09-28 19:43:08 +0000131static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132cifs_reconnect(struct TCP_Server_Info *server)
133{
134 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500135 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 struct cifsSesInfo *ses;
137 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000138 struct mid_q_entry *mid_entry;
Steve French50c2f752007-07-13 00:33:32 +0000139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000141 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000142 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 next time through the loop */
144 spin_unlock(&GlobalMid_Lock);
145 return rc;
146 } else
147 server->tcpStatus = CifsNeedReconnect;
148 spin_unlock(&GlobalMid_Lock);
149 server->maxBuf = 0;
150
Joe Perchesb6b38f72010-04-21 03:50:45 +0000151 cFYI(1, "Reconnecting tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 /* before reconnecting the tcp session, mark the smb session (uid)
154 and the tid bad so they are not used until reconnected */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530155 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500156 list_for_each(tmp, &server->smb_ses_list) {
157 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
158 ses->need_reconnect = true;
159 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500160 list_for_each(tmp2, &ses->tcon_list) {
161 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
162 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530165 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 /* do not want to be sending data on a socket we are freeing */
Jeff Layton72ca5452008-12-01 07:09:36 -0500167 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000168 if (server->ssocket) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000169 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
170 server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800171 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000172 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000173 server->ssocket->state,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000174 server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 sock_release(server->ssocket);
176 server->ssocket = NULL;
177 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500178 server->sequence_number = 0;
179 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500180 kfree(server->session_key.response);
181 server->session_key.response = NULL;
182 server->session_key.len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 spin_lock(&GlobalMid_Lock);
185 list_for_each(tmp, &server->pending_mid_q) {
186 mid_entry = list_entry(tmp, struct
187 mid_q_entry,
188 qhead);
Steve Frenchad8b15f2008-08-08 21:10:16 +0000189 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French09d1db52005-04-28 22:41:08 -0700190 /* Mark other intransit requests as needing
191 retry so we do not immediately mark the
192 session bad again (ie after we reconnect
193 below) as they timeout too */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000194 mid_entry->midState = MID_RETRY_NEEDED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 }
196 }
197 spin_unlock(&GlobalMid_Lock);
Jeff Layton72ca5452008-12-01 07:09:36 -0500198 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Jeff Layton469ee612008-10-16 18:46:39 +0000200 while ((server->tcpStatus != CifsExiting) &&
201 (server->tcpStatus != CifsGood)) {
Steve French6c3d8902006-07-31 22:46:20 +0000202 try_to_freeze();
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500203 if (server->addr.sockAddr6.sin6_family == AF_INET6)
Jeff Laytond5c56052008-12-01 18:42:33 -0500204 rc = ipv6_connect(server);
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500205 else
206 rc = ipv4_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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 server->tcpStatus = CifsGood;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000215 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 /* atomic_set(&server->inFlight,0);*/
217 wake_up(&server->response_q);
218 }
219 }
220 return rc;
221}
222
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000223/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700224 return codes:
225 0 not a transact2, or all data present
226 >0 transact2 with that much data missing
227 -EINVAL = invalid transact2
228
229 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000230static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700231{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000232 struct smb_t2_rsp *pSMBt;
233 int total_data_size;
Steve Frenche4eb2952005-04-28 22:41:09 -0700234 int data_in_this_rsp;
235 int remaining;
236
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000237 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700238 return 0;
239
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000240 /* check for plausible wct, bcc and t2 data and parm sizes */
241 /* check for parm and data offset going beyond end of smb */
242 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000243 cFYI(1, "invalid transact2 word count");
Steve Frenche4eb2952005-04-28 22:41:09 -0700244 return -EINVAL;
245 }
246
247 pSMBt = (struct smb_t2_rsp *)pSMB;
248
249 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
250 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
251
252 remaining = total_data_size - data_in_this_rsp;
253
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000254 if (remaining == 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700255 return 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000256 else if (remaining < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000257 cFYI(1, "total data %d smaller than data in frame %d",
258 total_data_size, data_in_this_rsp);
Steve Frenche4eb2952005-04-28 22:41:09 -0700259 return -EINVAL;
260 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000261 cFYI(1, "missing %d bytes from transact2, check next response",
262 remaining);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000263 if (total_data_size > maxBufSize) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000264 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
265 total_data_size, maxBufSize);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000266 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700267 }
268 return remaining;
269 }
270}
271
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000272static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700273{
274 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
275 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
276 int total_data_size;
277 int total_in_buf;
278 int remaining;
279 int total_in_buf2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000280 char *data_area_of_target;
281 char *data_area_of_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700282 __u16 byte_count;
283
284 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
285
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000286 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000287 cFYI(1, "total data size of primary and secondary t2 differ");
Steve Frenche4eb2952005-04-28 22:41:09 -0700288 }
289
290 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
291
292 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000293
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000294 if (remaining < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700295 return -EINVAL;
296
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000297 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700298 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000299
Steve Frenche4eb2952005-04-28 22:41:09 -0700300 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000301 if (remaining < total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000302 cFYI(1, "transact2 2nd response contains too much data");
Steve Frenche4eb2952005-04-28 22:41:09 -0700303 }
304
305 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000306 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Steve Frenche4eb2952005-04-28 22:41:09 -0700307 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
308 /* validate target area */
309
310 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000311 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700312
313 data_area_of_target += total_in_buf;
314
315 /* copy second buffer into end of first buffer */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000316 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
Steve Frenche4eb2952005-04-28 22:41:09 -0700317 total_in_buf += total_in_buf2;
318 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
319 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
320 byte_count += total_in_buf2;
321 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
322
Steve French70ca7342005-09-22 16:32:06 -0700323 byte_count = pTargetSMB->smb_buf_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700324 byte_count += total_in_buf2;
325
326 /* BB also add check that we are not beyond maximum buffer size */
Steve French50c2f752007-07-13 00:33:32 +0000327
Steve French70ca7342005-09-22 16:32:06 -0700328 pTargetSMB->smb_buf_length = byte_count;
Steve Frenche4eb2952005-04-28 22:41:09 -0700329
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000330 if (remaining == total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000331 cFYI(1, "found the last secondary response");
Steve Frenche4eb2952005-04-28 22:41:09 -0700332 return 0; /* we are done */
333 } else /* more responses to go */
334 return 1;
335
336}
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338static int
339cifs_demultiplex_thread(struct TCP_Server_Info *server)
340{
341 int length;
342 unsigned int pdu_length, total_read;
343 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700344 struct smb_hdr *bigbuf = NULL;
345 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 struct msghdr smb_msg;
347 struct kvec iov;
348 struct socket *csocket = server->ssocket;
349 struct list_head *tmp;
350 struct cifsSesInfo *ses;
351 struct task_struct *task_to_wake = NULL;
352 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700353 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000354 bool isLargeBuf = false;
355 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700356 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000359 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400360
361 length = atomic_inc_return(&tcpSesAllocCount);
362 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000363 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
364 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700366 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000367 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700368 if (try_to_freeze())
369 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700370 if (bigbuf == NULL) {
371 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000372 if (!bigbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000373 cERROR(1, "No memory for large SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700374 msleep(3000);
375 /* retry will check if exiting */
376 continue;
377 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000378 } else if (isLargeBuf) {
379 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000380 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700382
383 if (smallbuf == NULL) {
384 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000385 if (!smallbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000386 cERROR(1, "No memory for SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700387 msleep(1000);
388 /* retry will check if exiting */
389 continue;
390 }
391 /* beginning of smb buffer is cleared in our buf_get */
392 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000393 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700394
Steve French4b18f2a2008-04-29 00:06:05 +0000395 isLargeBuf = false;
396 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700397 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 iov.iov_base = smb_buffer;
399 iov.iov_len = 4;
400 smb_msg.msg_control = NULL;
401 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000402 pdu_length = 4; /* enough to get RFC1001 header */
403incomplete_rcv:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 length =
405 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000406 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Jeff Layton469ee612008-10-16 18:46:39 +0000408 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 break;
410 } else if (server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000411 cFYI(1, "Reconnect after server stopped responding");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 cifs_reconnect(server);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000413 cFYI(1, "call to reconnect done");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 csocket = server->ssocket;
415 continue;
Jeff Layton522bbe62010-09-03 12:00:49 -0400416 } else if (length == -ERESTARTSYS ||
417 length == -EAGAIN ||
418 length == -EINTR) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700419 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 allowing socket to clear and app threads to set
421 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000422 if (pdu_length < 4) {
423 iov.iov_base = (4 - pdu_length) +
424 (char *)smb_buffer;
425 iov.iov_len = pdu_length;
426 smb_msg.msg_control = NULL;
427 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000428 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000429 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000430 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000432 cFYI(1, "Reconnect after unexpected peek error %d",
433 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 cifs_reconnect(server);
435 csocket = server->ssocket;
436 wake_up(&server->response_q);
437 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000438 } else if (length < pdu_length) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000439 cFYI(1, "requested %d bytes but only got %d bytes",
440 pdu_length, length);
Steve Frenchf01d5e12007-08-30 21:13:31 +0000441 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000442 msleep(1);
443 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
Steve French67010fb2005-04-28 22:41:09 -0700445
Steve French70ca7342005-09-22 16:32:06 -0700446 /* The right amount was read from socket - 4 bytes */
447 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700448
Steve French70ca7342005-09-22 16:32:06 -0700449 /* the first byte big endian of the length field,
450 is actually not part of the length but the type
451 with the most common, zero, as regular data */
452 temp = *((char *) smb_buffer);
453
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000454 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700455 but we convert it here so it is always manipulated
456 as host byte order */
Harvey Harrison5ca33c62008-07-23 17:45:58 -0700457 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
Steve French70ca7342005-09-22 16:32:06 -0700458 smb_buffer->smb_buf_length = pdu_length;
Steve French46810cb2005-04-28 22:41:09 -0700459
Joe Perchesb6b38f72010-04-21 03:50:45 +0000460 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
Steve French70ca7342005-09-22 16:32:06 -0700461
462 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000463 continue;
Steve French70ca7342005-09-22 16:32:06 -0700464 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000465 cFYI(1, "Good RFC 1002 session rsp");
Steve Frenche4eb2952005-04-28 22:41:09 -0700466 continue;
Steve French70ca7342005-09-22 16:32:06 -0700467 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000468 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700469 an error on SMB negprot response */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000470 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
471 pdu_length);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400472 /* give server a second to clean up */
473 msleep(1000);
474 /* always try 445 first on reconnect since we get NACK
475 * on some if we ever connected to port 139 (the NACK
476 * is since we do not begin with RFC1001 session
477 * initialize frame)
478 */
Jeff Layton32670392010-09-03 12:00:50 -0400479 cifs_set_port((struct sockaddr *)
480 &server->addr.sockAddr, CIFS_PORT);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400481 cifs_reconnect(server);
482 csocket = server->ssocket;
483 wake_up(&server->response_q);
484 continue;
Steve French70ca7342005-09-22 16:32:06 -0700485 } else if (temp != (char) 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000486 cERROR(1, "Unknown RFC 1002 frame");
Steve French70ca7342005-09-22 16:32:06 -0700487 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
488 length);
Steve French46810cb2005-04-28 22:41:09 -0700489 cifs_reconnect(server);
490 csocket = server->ssocket;
491 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700492 }
493
494 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000495 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000496 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000497 cERROR(1, "Invalid size SMB length %d pdu_length %d",
498 length, pdu_length+4);
Steve Frenche4eb2952005-04-28 22:41:09 -0700499 cifs_reconnect(server);
500 csocket = server->ssocket;
501 wake_up(&server->response_q);
502 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000503 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700504
505 /* else length ok */
506 reconnect = 0;
507
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000508 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000509 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700510 memcpy(bigbuf, smallbuf, 4);
511 smb_buffer = bigbuf;
512 }
513 length = 0;
514 iov.iov_base = 4 + (char *)smb_buffer;
515 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000516 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700517 total_read += length) {
518 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
519 pdu_length - total_read, 0);
Jeff Layton522bbe62010-09-03 12:00:49 -0400520 if (server->tcpStatus == CifsExiting) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700521 /* then will exit */
522 reconnect = 2;
523 break;
524 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700525 cifs_reconnect(server);
526 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000527 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700528 /* Now we will reread sock */
529 reconnect = 1;
530 break;
Jeff Layton522bbe62010-09-03 12:00:49 -0400531 } else if (length == -ERESTARTSYS ||
532 length == -EAGAIN ||
533 length == -EINTR) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700534 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000535 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700536 threads to set tcpStatus
537 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000538 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700539 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700540 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000541 cERROR(1, "Received no data, expecting %d",
542 pdu_length - total_read);
Steve Frenche4eb2952005-04-28 22:41:09 -0700543 cifs_reconnect(server);
544 csocket = server->ssocket;
545 reconnect = 1;
546 break;
Steve French46810cb2005-04-28 22:41:09 -0700547 }
548 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000549 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700550 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000551 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700552 continue;
553
554 length += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000555
Steve Frenche4eb2952005-04-28 22:41:09 -0700556
557 dump_smb(smb_buffer, length);
Steve French184ed212006-02-24 06:15:11 +0000558 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
Steve Frenchb387eae2005-10-10 14:21:15 -0700559 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
Steve Frenche4eb2952005-04-28 22:41:09 -0700560 continue;
561 }
562
563
564 task_to_wake = NULL;
565 spin_lock(&GlobalMid_Lock);
566 list_for_each(tmp, &server->pending_mid_q) {
567 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
568
Steve French50c2f752007-07-13 00:33:32 +0000569 if ((mid_entry->mid == smb_buffer->Mid) &&
Steve Frenche4eb2952005-04-28 22:41:09 -0700570 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
571 (mid_entry->command == smb_buffer->Command)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000572 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700573 /* We have a multipart transact2 resp */
Steve French4b18f2a2008-04-29 00:06:05 +0000574 isMultiRsp = true;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000575 if (mid_entry->resp_buf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700576 /* merge response - fix up 1st*/
Steve French50c2f752007-07-13 00:33:32 +0000577 if (coalesce_t2(smb_buffer,
Steve Frenche4eb2952005-04-28 22:41:09 -0700578 mid_entry->resp_buf)) {
Steve French4b18f2a2008-04-29 00:06:05 +0000579 mid_entry->multiRsp =
580 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700581 break;
582 } else {
583 /* all parts received */
Steve French4b18f2a2008-04-29 00:06:05 +0000584 mid_entry->multiEnd =
585 true;
Steve French50c2f752007-07-13 00:33:32 +0000586 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700587 }
588 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000589 if (!isLargeBuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000590 cERROR(1, "1st trans2 resp needs bigbuf");
Steve Frenche4eb2952005-04-28 22:41:09 -0700591 /* BB maybe we can fix this up, switch
Steve French50c2f752007-07-13 00:33:32 +0000592 to already allocated large buffer? */
Steve Frenche4eb2952005-04-28 22:41:09 -0700593 } else {
Steve Frenchcd634992005-04-28 22:41:10 -0700594 /* Have first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700595 mid_entry->resp_buf =
596 smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000597 mid_entry->largeBuf =
598 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700599 bigbuf = NULL;
600 }
601 }
602 break;
Steve French50c2f752007-07-13 00:33:32 +0000603 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700604 mid_entry->resp_buf = smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000605 mid_entry->largeBuf = isLargeBuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700606multi_t2_fnd:
607 task_to_wake = mid_entry->tsk;
608 mid_entry->midState = MID_RESPONSE_RECEIVED;
Steve French1047abc2005-10-11 19:58:06 -0700609#ifdef CONFIG_CIFS_STATS2
610 mid_entry->when_received = jiffies;
611#endif
Steve French3a5ff612006-07-14 22:37:11 +0000612 /* so we do not time out requests to server
613 which is still responding (since server could
614 be busy but not dead) */
615 server->lstrp = jiffies;
Steve Frenche4eb2952005-04-28 22:41:09 -0700616 break;
617 }
618 }
619 spin_unlock(&GlobalMid_Lock);
620 if (task_to_wake) {
Steve Frenchcd634992005-04-28 22:41:10 -0700621 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000622 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700623 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000624 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700625 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000626 else
Steve Frenchcd634992005-04-28 22:41:10 -0700627 smallbuf = NULL;
628 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700629 wake_up_process(task_to_wake);
Steve French4b18f2a2008-04-29 00:06:05 +0000630 } else if (!is_valid_oplock_break(smb_buffer, server) &&
631 !isMultiRsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000632 cERROR(1, "No task to wake, unknown frame received! "
633 "NumMids %d", midCount.counter);
Steve French50c2f752007-07-13 00:33:32 +0000634 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700635 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000636#ifdef CONFIG_CIFS_DEBUG2
637 cifs_dump_detail(smb_buffer);
638 cifs_dump_mids(server);
639#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000640
Steve Frenche4eb2952005-04-28 22:41:09 -0700641 }
642 } /* end while !EXITING */
643
Jeff Laytone7ddee92008-11-14 13:44:38 -0500644 /* take it off the list, if it's not already */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530645 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500646 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530647 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 spin_lock(&GlobalMid_Lock);
650 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000651 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000652 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000653
Steve French31ca3bc2005-04-28 22:41:11 -0700654 /* check if we have blocked requests that need to free */
655 /* Note that cifs_max_pending is normally 50, but
656 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000657 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000658 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700659 atomic_set(&server->inFlight, cifs_max_pending - 1);
660 /* We do not want to set the max_pending too low or we
661 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000663 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700665 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 to the same server - they now will see the session is in exit state
667 and get out of SendReceive. */
668 wake_up_all(&server->request_q);
669 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700670 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000671
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000672 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 sock_release(csocket);
674 server->ssocket = NULL;
675 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700676 /* buffer usuallly freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000677 cifs_buf_release(bigbuf);
678 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700679 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Jeff Layton14fbf502008-11-14 13:53:46 -0500681 /*
682 * BB: we shouldn't have to do any of this. It shouldn't be
683 * possible to exit from the thread with active SMB sessions
684 */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530685 spin_lock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (list_empty(&server->pending_mid_q)) {
Steve French09d1db52005-04-28 22:41:08 -0700687 /* loop through server session structures attached to this and
688 mark them dead */
Jeff Layton14fbf502008-11-14 13:53:46 -0500689 list_for_each(tmp, &server->smb_ses_list) {
690 ses = list_entry(tmp, struct cifsSesInfo,
691 smb_ses_list);
692 ses->status = CifsExiting;
693 ses->server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530695 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 } else {
Steve French31ca3bc2005-04-28 22:41:11 -0700697 /* although we can not zero the server struct pointer yet,
698 since there are active requests which may depnd on them,
699 mark the corresponding SMB sessions as exiting too */
Jeff Layton14fbf502008-11-14 13:53:46 -0500700 list_for_each(tmp, &server->smb_ses_list) {
Steve French31ca3bc2005-04-28 22:41:11 -0700701 ses = list_entry(tmp, struct cifsSesInfo,
Jeff Layton14fbf502008-11-14 13:53:46 -0500702 smb_ses_list);
703 ses->status = CifsExiting;
Steve French31ca3bc2005-04-28 22:41:11 -0700704 }
705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 spin_lock(&GlobalMid_Lock);
707 list_for_each(tmp, &server->pending_mid_q) {
708 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
709 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000710 cFYI(1, "Clearing Mid 0x%x - waking up ",
711 mid_entry->mid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 task_to_wake = mid_entry->tsk;
Steve French26f57362007-08-30 22:09:15 +0000713 if (task_to_wake)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 wake_up_process(task_to_wake);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 }
716 }
717 spin_unlock(&GlobalMid_Lock);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530718 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700720 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 }
722
Steve Frenchf1914012005-08-18 09:37:34 -0700723 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000724 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700726 /* due to delays on oplock break requests, we need
727 to wait at least 45 seconds before giving up
728 on a request getting a response and going ahead
729 and killing cifsd */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000730 cFYI(1, "Wait for exit from demultiplex thread");
Steve French31ca3bc2005-04-28 22:41:11 -0700731 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 /* if threads still have not exited they are probably never
733 coming home not much else we can do but free the memory */
734 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Steve French31ca3bc2005-04-28 22:41:11 -0700736 /* last chance to mark ses pointers invalid
737 if there are any pointing to this (e.g
Steve French50c2f752007-07-13 00:33:32 +0000738 if a crazy root user tried to kill cifsd
Steve French31ca3bc2005-04-28 22:41:11 -0700739 kernel thread explicitly this might happen) */
Jeff Layton14fbf502008-11-14 13:53:46 -0500740 /* BB: This shouldn't be necessary, see above */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530741 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500742 list_for_each(tmp, &server->smb_ses_list) {
743 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
744 ses->server = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700745 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530746 spin_unlock(&cifs_tcp_ses_lock);
Steve French31ca3bc2005-04-28 22:41:11 -0700747
Jeff Laytonc359cf32007-11-16 22:22:06 +0000748 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400749 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700750 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400751
752 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000753 if (length > 0)
754 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
755 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000756
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400757 /* if server->tsk was NULL then wait for a signal before exiting */
758 if (!task_to_wake) {
759 set_current_state(TASK_INTERRUPTIBLE);
760 while (!signal_pending(current)) {
761 schedule();
762 set_current_state(TASK_INTERRUPTIBLE);
763 }
764 set_current_state(TASK_RUNNING);
765 }
766
Jeff Layton0468a2c2008-12-01 07:09:35 -0500767 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
Jeff Laytonc359cf32007-11-16 22:22:06 +0000770/* extract the host portion of the UNC string */
771static char *
772extract_hostname(const char *unc)
773{
774 const char *src;
775 char *dst, *delim;
776 unsigned int len;
777
778 /* skip double chars at beginning of string */
779 /* BB: check validity of these bytes? */
780 src = unc + 2;
781
782 /* delimiter between hostname and sharename is always '\\' now */
783 delim = strchr(src, '\\');
784 if (!delim)
785 return ERR_PTR(-EINVAL);
786
787 len = delim - src;
788 dst = kmalloc((len + 1), GFP_KERNEL);
789 if (dst == NULL)
790 return ERR_PTR(-ENOMEM);
791
792 memcpy(dst, src, len);
793 dst[len] = '\0';
794
795 return dst;
796}
797
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798static int
Steve French50c2f752007-07-13 00:33:32 +0000799cifs_parse_mount_options(char *options, const char *devname,
800 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
802 char *value;
803 char *data;
804 unsigned int temp_len, i, j;
805 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -0400806 short int override_uid = -1;
807 short int override_gid = -1;
808 bool uid_specified = false;
809 bool gid_specified = false;
Jeff Layton88463992010-11-22 15:31:03 -0500810 char *nodename = utsname()->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000813 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Jeff Layton88463992010-11-22 15:31:03 -0500815 /*
816 * does not have to be perfect mapping since field is
817 * informational, only used for servers that do not support
818 * port 445 and it can be overridden at mount time
819 */
820 memset(vol->source_rfc1001_name, 0x20, 15);
821 for (i = 0; i < strnlen(nodename, 15); i++)
822 vol->source_rfc1001_name[i] = toupper(nodename[i]);
823
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 vol->source_rfc1001_name[15] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700825 /* null target name indicates to use *SMBSERVR default called name
826 if we end up sending RFC1001 session initialize */
827 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400828 vol->cred_uid = current_uid();
829 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +1100830 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400831
832 /* default to only allowing write access to owner of the mount */
833 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -0700836 /* default is always to request posix paths. */
837 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400838 /* default to using server inode numbers where available */
839 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700840
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530841 vol->actimeo = CIFS_DEF_ACTIMEO;
842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (!options)
844 return 1;
845
Steve French50c2f752007-07-13 00:33:32 +0000846 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000847 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 separator[0] = options[4];
849 options += 5;
850 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000851 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 }
853 }
Steve French50c2f752007-07-13 00:33:32 +0000854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 while ((data = strsep(&options, separator)) != NULL) {
856 if (!*data)
857 continue;
858 if ((value = strchr(data, '=')) != NULL)
859 *value++ = '\0';
860
Steve French50c2f752007-07-13 00:33:32 +0000861 /* Have to parse this before we parse for "user" */
862 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000864 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 vol->no_xattr = 1;
866 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000867 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 printk(KERN_WARNING
869 "CIFS: invalid or missing username\n");
870 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000871 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000872 /* null user, ie anonymous, authentication */
873 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
875 if (strnlen(value, 200) < 200) {
876 vol->username = value;
877 } else {
878 printk(KERN_WARNING "CIFS: username too long\n");
879 return 1;
880 }
881 } else if (strnicmp(data, "pass", 4) == 0) {
882 if (!value) {
883 vol->password = NULL;
884 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000885 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 /* check if string begins with double comma
887 since that would mean the password really
888 does start with a comma, and would not
889 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000890 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 vol->password = NULL;
892 continue;
893 }
894 }
895 temp_len = strlen(value);
896 /* removed password length check, NTLM passwords
897 can be arbitrarily long */
898
Steve French50c2f752007-07-13 00:33:32 +0000899 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 prematurely null terminated. Commas in password are
901 specified across the cifs mount interface by a double
902 comma ie ,, and a comma used as in other cases ie ','
903 as a parameter delimiter/separator is single and due
904 to the strsep above is temporarily zeroed. */
905
906 /* NB: password legally can have multiple commas and
907 the only illegal character in a password is null */
908
Steve French50c2f752007-07-13 00:33:32 +0000909 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700910 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 /* reinsert comma */
912 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000913 temp_len += 2; /* move after second comma */
914 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000916 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700917 separator[0]) {
918 /* skip second comma */
919 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000920 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 /* single comma indicating start
922 of next parm */
923 break;
924 }
925 }
926 temp_len++;
927 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000928 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 options = NULL;
930 } else {
931 value[temp_len] = 0;
932 /* point option to start of next parm */
933 options = value + temp_len + 1;
934 }
Steve French50c2f752007-07-13 00:33:32 +0000935 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 double commas to singles. Note that this ends up
937 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700938 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000939 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000940 printk(KERN_WARNING "CIFS: no memory "
941 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700942 return 1;
943 }
Steve French50c2f752007-07-13 00:33:32 +0000944 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000946 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700947 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 /* skip second comma */
949 i++;
950 }
951 }
952 vol->password[j] = 0;
953 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700954 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000955 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000956 printk(KERN_WARNING "CIFS: no memory "
957 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700958 return 1;
959 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 strcpy(vol->password, value);
961 }
Jeff Layton58f7f682009-06-10 09:57:55 -0400962 } else if (!strnicmp(data, "ip", 2) ||
963 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (!value || !*value) {
965 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -0400966 } else if (strnlen(value, INET6_ADDRSTRLEN) <
967 INET6_ADDRSTRLEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 vol->UNCip = value;
969 } else {
Steve French50c2f752007-07-13 00:33:32 +0000970 printk(KERN_WARNING "CIFS: ip address "
971 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 return 1;
973 }
Steve French50c2f752007-07-13 00:33:32 +0000974 } else if (strnicmp(data, "sec", 3) == 0) {
975 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000976 cERROR(1, "no security value specified");
Steve French50c2f752007-07-13 00:33:32 +0000977 continue;
978 } else if (strnicmp(value, "krb5i", 5) == 0) {
979 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000980 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800981 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000982 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
983 CIFSSEC_MAY_KRB5; */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000984 cERROR(1, "Krb5 cifs privacy not supported");
Steve Frenchbf820672005-12-01 22:32:42 -0800985 return 1;
986 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000987 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +0000988#ifdef CONFIG_CIFS_EXPERIMENTAL
989 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
990 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
991 CIFSSEC_MUST_SIGN;
992 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
993 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
994#endif
Steve Frenchbf820672005-12-01 22:32:42 -0800995 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000996 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000997 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800998 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000999 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -08001000 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001001 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +00001002 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001003 } else if (strnicmp(value, "ntlm", 4) == 0) {
1004 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001005 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001006 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001007 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001008 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001009#ifdef CONFIG_CIFS_WEAK_PW_HASH
1010 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001011 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001012#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001013 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001014 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001015 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001016 cERROR(1, "bad security option: %s", value);
Steve French50c2f752007-07-13 00:33:32 +00001017 return 1;
1018 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 } else if ((strnicmp(data, "unc", 3) == 0)
1020 || (strnicmp(data, "target", 6) == 0)
1021 || (strnicmp(data, "path", 4) == 0)) {
1022 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001023 printk(KERN_WARNING "CIFS: invalid path to "
1024 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 return 1; /* needs_arg; */
1026 }
1027 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001028 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001029 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001031 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 if (strncmp(vol->UNC, "//", 2) == 0) {
1033 vol->UNC[0] = '\\';
1034 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001035 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001037 "CIFS: UNC Path does not begin "
1038 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 return 1;
1040 }
1041 } else {
1042 printk(KERN_WARNING "CIFS: UNC name too long\n");
1043 return 1;
1044 }
1045 } else if ((strnicmp(data, "domain", 3) == 0)
1046 || (strnicmp(data, "workgroup", 5) == 0)) {
1047 if (!value || !*value) {
1048 printk(KERN_WARNING "CIFS: invalid domain name\n");
1049 return 1; /* needs_arg; */
1050 }
1051 /* BB are there cases in which a comma can be valid in
1052 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001053 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 vol->domainname = value;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001055 cFYI(1, "Domain name set");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 } else {
Steve French50c2f752007-07-13 00:33:32 +00001057 printk(KERN_WARNING "CIFS: domain name too "
1058 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 return 1;
1060 }
Ben Greear3eb9a882010-09-01 17:06:02 -07001061 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1062 vol->srcaddr.ss_family = AF_UNSPEC;
1063
1064 if (!value || !*value) {
1065 printk(KERN_WARNING "CIFS: srcaddr value"
1066 " not specified.\n");
1067 return 1; /* needs_arg; */
1068 }
1069 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1070 value, strlen(value));
Dan Carpenterb235f372010-10-25 07:02:56 +02001071 if (i == 0) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001072 printk(KERN_WARNING "CIFS: Could not parse"
1073 " srcaddr: %s\n",
1074 value);
1075 return 1;
1076 }
Steve French50c2f752007-07-13 00:33:32 +00001077 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1078 if (!value || !*value) {
1079 printk(KERN_WARNING
1080 "CIFS: invalid path prefix\n");
1081 return 1; /* needs_argument */
1082 }
1083 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001084 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001085 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001086 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1087 if (vol->prepath == NULL)
1088 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001089 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001090 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001091 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001092 } else
Steve French50c2f752007-07-13 00:33:32 +00001093 strcpy(vol->prepath, value);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001094 cFYI(1, "prefix path %s", vol->prepath);
Steve French50c2f752007-07-13 00:33:32 +00001095 } else {
1096 printk(KERN_WARNING "CIFS: prefix too long\n");
1097 return 1;
1098 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 } else if (strnicmp(data, "iocharset", 9) == 0) {
1100 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001101 printk(KERN_WARNING "CIFS: invalid iocharset "
1102 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 return 1; /* needs_arg; */
1104 }
1105 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001106 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001108 /* if iocharset not set then load_nls_default
1109 is used by caller */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001110 cFYI(1, "iocharset set to %s", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 } else {
Steve French63135e02007-07-17 17:34:02 +00001112 printk(KERN_WARNING "CIFS: iocharset name "
1113 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 return 1;
1115 }
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001116 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1117 vol->linux_uid = simple_strtoul(value, &value, 0);
1118 uid_specified = true;
1119 } else if (!strnicmp(data, "forceuid", 8)) {
1120 override_uid = 1;
1121 } else if (!strnicmp(data, "noforceuid", 10)) {
1122 override_uid = 0;
1123 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1124 vol->linux_gid = simple_strtoul(value, &value, 0);
1125 gid_specified = true;
1126 } else if (!strnicmp(data, "forcegid", 8)) {
1127 override_gid = 1;
1128 } else if (!strnicmp(data, "noforcegid", 10)) {
1129 override_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 } else if (strnicmp(data, "file_mode", 4) == 0) {
1131 if (value && *value) {
1132 vol->file_mode =
1133 simple_strtoul(value, &value, 0);
1134 }
1135 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1136 if (value && *value) {
1137 vol->dir_mode =
1138 simple_strtoul(value, &value, 0);
1139 }
1140 } else if (strnicmp(data, "dirmode", 4) == 0) {
1141 if (value && *value) {
1142 vol->dir_mode =
1143 simple_strtoul(value, &value, 0);
1144 }
1145 } else if (strnicmp(data, "port", 4) == 0) {
1146 if (value && *value) {
1147 vol->port =
1148 simple_strtoul(value, &value, 0);
1149 }
1150 } else if (strnicmp(data, "rsize", 5) == 0) {
1151 if (value && *value) {
1152 vol->rsize =
1153 simple_strtoul(value, &value, 0);
1154 }
1155 } else if (strnicmp(data, "wsize", 5) == 0) {
1156 if (value && *value) {
1157 vol->wsize =
1158 simple_strtoul(value, &value, 0);
1159 }
1160 } else if (strnicmp(data, "sockopt", 5) == 0) {
Steve French6a5fa2362010-01-01 01:28:43 +00001161 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001162 cERROR(1, "no socket option specified");
Steve French6a5fa2362010-01-01 01:28:43 +00001163 continue;
1164 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1165 vol->sockopt_tcp_nodelay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 }
1167 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1168 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001169 cFYI(1, "invalid (empty) netbiosname");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 } else {
Steve French50c2f752007-07-13 00:33:32 +00001171 memset(vol->source_rfc1001_name, 0x20, 15);
1172 for (i = 0; i < 15; i++) {
1173 /* BB are there cases in which a comma can be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 valid in this workstation netbios name (and need
1175 special handling)? */
1176
1177 /* We do not uppercase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001178 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 break;
Steve French50c2f752007-07-13 00:33:32 +00001180 else
1181 vol->source_rfc1001_name[i] =
1182 value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
1184 /* The string has 16th byte zero still from
1185 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001186 if ((i == 15) && (value[i] != 0))
1187 printk(KERN_WARNING "CIFS: netbiosname"
1188 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001189 }
1190 } else if (strnicmp(data, "servern", 7) == 0) {
1191 /* servernetbiosname specified override *SMBSERVER */
1192 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001193 cFYI(1, "empty server netbiosname specified");
Steve Frencha10faeb22005-08-22 21:38:31 -07001194 } else {
1195 /* last byte, type, is 0x20 for servr type */
Steve French50c2f752007-07-13 00:33:32 +00001196 memset(vol->target_rfc1001_name, 0x20, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001197
Steve French50c2f752007-07-13 00:33:32 +00001198 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001199 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001200 valid in this workstation netbios name
1201 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001202
Steve French50c2f752007-07-13 00:33:32 +00001203 /* user or mount helper must uppercase
1204 the netbiosname */
1205 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001206 break;
1207 else
Steve French50c2f752007-07-13 00:33:32 +00001208 vol->target_rfc1001_name[i] =
1209 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001210 }
1211 /* The string has 16th byte zero still from
1212 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001213 if ((i == 15) && (value[i] != 0))
1214 printk(KERN_WARNING "CIFS: server net"
1215 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 }
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301217 } else if (strnicmp(data, "actimeo", 7) == 0) {
1218 if (value && *value) {
1219 vol->actimeo = HZ * simple_strtoul(value,
1220 &value, 0);
1221 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1222 cERROR(1, "CIFS: attribute cache"
1223 "timeout too large");
1224 return 1;
1225 }
1226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 } else if (strnicmp(data, "credentials", 4) == 0) {
1228 /* ignore */
1229 } else if (strnicmp(data, "version", 3) == 0) {
1230 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001231 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 /* ignore */
Steve French71a394f2009-06-26 04:07:18 +00001233 } else if (strnicmp(data, "rw", 2) == 0) {
1234 /* ignore */
1235 } else if (strnicmp(data, "ro", 2) == 0) {
1236 /* ignore */
Steve Frenchedf1ae42008-10-29 00:47:57 +00001237 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1238 vol->noblocksnd = 1;
1239 } else if (strnicmp(data, "noautotune", 10) == 0) {
1240 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 } else if ((strnicmp(data, "suid", 4) == 0) ||
1242 (strnicmp(data, "nosuid", 6) == 0) ||
1243 (strnicmp(data, "exec", 4) == 0) ||
1244 (strnicmp(data, "noexec", 6) == 0) ||
1245 (strnicmp(data, "nodev", 5) == 0) ||
1246 (strnicmp(data, "noauto", 6) == 0) ||
1247 (strnicmp(data, "dev", 3) == 0)) {
1248 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001249 uses these opts to set flags, and the flags are read
1250 by the kernel vfs layer before we get here (ie
1251 before read super) so there is no point trying to
1252 parse these options again and set anything and it
1253 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 } else if (strnicmp(data, "hard", 4) == 0) {
1256 vol->retry = 1;
1257 } else if (strnicmp(data, "soft", 4) == 0) {
1258 vol->retry = 0;
1259 } else if (strnicmp(data, "perm", 4) == 0) {
1260 vol->noperm = 0;
1261 } else if (strnicmp(data, "noperm", 6) == 0) {
1262 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001263 } else if (strnicmp(data, "mapchars", 8) == 0) {
1264 vol->remap = 1;
1265 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1266 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001267 } else if (strnicmp(data, "sfu", 3) == 0) {
1268 vol->sfu_emul = 1;
1269 } else if (strnicmp(data, "nosfu", 5) == 0) {
1270 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001271 } else if (strnicmp(data, "nodfs", 5) == 0) {
1272 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001273 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1274 vol->posix_paths = 1;
1275 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1276 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001277 } else if (strnicmp(data, "nounix", 6) == 0) {
1278 vol->no_linux_ext = 1;
1279 } else if (strnicmp(data, "nolinux", 7) == 0) {
1280 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001281 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001282 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001283 vol->nocase = 1;
Jeff Laytonf636a342010-07-26 10:29:58 -04001284 } else if (strnicmp(data, "mand", 4) == 0) {
1285 /* ignore */
1286 } else if (strnicmp(data, "nomand", 6) == 0) {
1287 /* ignore */
1288 } else if (strnicmp(data, "_netdev", 7) == 0) {
1289 /* ignore */
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001290 } else if (strnicmp(data, "brl", 3) == 0) {
1291 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001292 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001293 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001294 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001295 /* turn off mandatory locking in mode
1296 if remote locking is turned off since the
1297 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001298 if (vol->file_mode ==
1299 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001300 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001301 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1302 /* will take the shorter form "forcemand" as well */
1303 /* This mount option will force use of mandatory
1304 (DOS/Windows style) byte range locks, instead of
1305 using posix advisory byte range locks, even if the
1306 Unix extensions are available and posix locks would
1307 be supported otherwise. If Unix extensions are not
1308 negotiated this has no effect since mandatory locks
1309 would be used (mandatory locks is all that those
1310 those servers support) */
1311 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 } else if (strnicmp(data, "setuids", 7) == 0) {
1313 vol->setuids = 1;
1314 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1315 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001316 } else if (strnicmp(data, "dynperm", 7) == 0) {
1317 vol->dynperm = true;
1318 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1319 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 } else if (strnicmp(data, "nohard", 6) == 0) {
1321 vol->retry = 0;
1322 } else if (strnicmp(data, "nosoft", 6) == 0) {
1323 vol->retry = 1;
1324 } else if (strnicmp(data, "nointr", 6) == 0) {
1325 vol->intr = 0;
1326 } else if (strnicmp(data, "intr", 4) == 0) {
1327 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001328 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1329 vol->nostrictsync = 1;
1330 } else if (strnicmp(data, "strictsync", 10) == 0) {
1331 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001332 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001334 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001336 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001337 vol->cifs_acl = 1;
1338 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1339 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001340 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001342 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001344#ifdef CONFIG_CIFS_EXPERIMENTAL
1345 } else if (strnicmp(data, "locallease", 6) == 0) {
1346 vol->local_lease = 1;
1347#endif
Steve French50c2f752007-07-13 00:33:32 +00001348 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001349 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001350 } else if (strnicmp(data, "seal", 4) == 0) {
1351 /* we do not do the following in secFlags because seal
1352 is a per tree connection (mount) not a per socket
1353 or per-smb connection option in the protocol */
1354 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1355 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001356 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001358 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 vol->direct_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001361 printk(KERN_WARNING "CIFS: Mount option noac not "
1362 "supported. Instead set "
1363 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301364 } else if (strnicmp(data, "fsc", 3) == 0) {
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301365#ifndef CONFIG_CIFS_FSCACHE
1366 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1367 "kernel config option set");
1368 return 1;
1369#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301370 vol->fsc = true;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001371 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1372 vol->mfsymlinks = true;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001373 } else if (strnicmp(data, "multiuser", 8) == 0) {
1374 vol->multiuser = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 } else
Steve French50c2f752007-07-13 00:33:32 +00001376 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1377 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 }
1379 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001380 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001381 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1382 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 return 1;
1384 }
1385 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001386 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001387 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001389 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 if (strncmp(vol->UNC, "//", 2) == 0) {
1391 vol->UNC[0] = '\\';
1392 vol->UNC[1] = '\\';
1393 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001394 printk(KERN_WARNING "CIFS: UNC Path does not "
1395 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 return 1;
1397 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001398 value = strpbrk(vol->UNC+2, "/\\");
1399 if (value)
1400 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 } else {
1402 printk(KERN_WARNING "CIFS: UNC name too long\n");
1403 return 1;
1404 }
1405 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001406
1407 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1408 cERROR(1, "Multiuser mounts currently require krb5 "
1409 "authentication!");
1410 return 1;
1411 }
1412
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001413 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 vol->UNCip = &vol->UNC[2];
1415
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001416 if (uid_specified)
1417 vol->override_uid = override_uid;
1418 else if (override_uid == 1)
1419 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1420 "specified with no uid= option.\n");
1421
1422 if (gid_specified)
1423 vol->override_gid = override_gid;
1424 else if (override_gid == 1)
1425 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1426 "specified with no gid= option.\n");
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 return 0;
1429}
1430
Ben Greear3eb9a882010-09-01 17:06:02 -07001431/** Returns true if srcaddr isn't specified and rhs isn't
1432 * specified, or if srcaddr is specified and
1433 * matches the IP address of the rhs argument.
1434 */
Jeff Layton45151482010-07-06 20:43:02 -04001435static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001436srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1437{
1438 switch (srcaddr->sa_family) {
1439 case AF_UNSPEC:
1440 return (rhs->sa_family == AF_UNSPEC);
1441 case AF_INET: {
1442 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1443 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1444 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1445 }
1446 case AF_INET6: {
1447 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1448 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1449 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1450 }
1451 default:
1452 WARN_ON(1);
1453 return false; /* don't expect to be here */
1454 }
1455}
1456
1457
1458static bool
1459match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1460 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461{
Jeff Layton45151482010-07-06 20:43:02 -04001462 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1463 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1464
1465 switch (addr->sa_family) {
1466 case AF_INET:
1467 if (addr4->sin_addr.s_addr !=
1468 server->addr.sockAddr.sin_addr.s_addr)
1469 return false;
1470 if (addr4->sin_port &&
1471 addr4->sin_port != server->addr.sockAddr.sin_port)
1472 return false;
1473 break;
1474 case AF_INET6:
1475 if (!ipv6_addr_equal(&addr6->sin6_addr,
1476 &server->addr.sockAddr6.sin6_addr))
1477 return false;
1478 if (addr6->sin6_scope_id !=
1479 server->addr.sockAddr6.sin6_scope_id)
1480 return false;
1481 if (addr6->sin6_port &&
1482 addr6->sin6_port != server->addr.sockAddr6.sin6_port)
1483 return false;
1484 break;
1485 }
1486
Ben Greear3eb9a882010-09-01 17:06:02 -07001487 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1488 return false;
1489
Jeff Layton45151482010-07-06 20:43:02 -04001490 return true;
1491}
1492
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001493static bool
1494match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1495{
1496 unsigned int secFlags;
1497
1498 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1499 secFlags = vol->secFlg;
1500 else
1501 secFlags = global_secflags | vol->secFlg;
1502
1503 switch (server->secType) {
1504 case LANMAN:
1505 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1506 return false;
1507 break;
1508 case NTLMv2:
1509 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1510 return false;
1511 break;
1512 case NTLM:
1513 if (!(secFlags & CIFSSEC_MAY_NTLM))
1514 return false;
1515 break;
1516 case Kerberos:
1517 if (!(secFlags & CIFSSEC_MAY_KRB5))
1518 return false;
1519 break;
1520 case RawNTLMSSP:
1521 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1522 return false;
1523 break;
1524 default:
1525 /* shouldn't happen */
1526 return false;
1527 }
1528
1529 /* now check if signing mode is acceptible */
1530 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1531 (server->secMode & SECMODE_SIGN_REQUIRED))
1532 return false;
1533 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1534 (server->secMode &
1535 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1536 return false;
1537
1538 return true;
1539}
1540
Jeff Layton45151482010-07-06 20:43:02 -04001541static struct TCP_Server_Info *
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001542cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04001543{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001544 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301546 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04001547 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001548 if (!match_address(server, addr,
1549 (struct sockaddr *)&vol->srcaddr))
Jeff Layton45151482010-07-06 20:43:02 -04001550 continue;
Steve French50c2f752007-07-13 00:33:32 +00001551
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001552 if (!match_security(server, vol))
1553 continue;
1554
Jeff Laytone7ddee92008-11-14 13:44:38 -05001555 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301556 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001557 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05001558 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301560 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 return NULL;
1562}
1563
Jeff Layton14fbf502008-11-14 13:53:46 -05001564static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001565cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001567 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301569 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001570 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301571 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001572 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001574
Jeff Laytone7ddee92008-11-14 13:44:38 -05001575 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301576 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001577
1578 spin_lock(&GlobalMid_Lock);
1579 server->tcpStatus = CifsExiting;
1580 spin_unlock(&GlobalMid_Lock);
1581
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001582 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301583 cifs_fscache_release_client_cookie(server);
1584
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05001585 kfree(server->session_key.response);
1586 server->session_key.response = NULL;
1587 server->session_key.len = 0;
1588
Jeff Laytone7ddee92008-11-14 13:44:38 -05001589 task = xchg(&server->tsk, NULL);
1590 if (task)
1591 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592}
1593
Jeff Layton63c038c2008-12-01 18:41:46 -05001594static struct TCP_Server_Info *
1595cifs_get_tcp_session(struct smb_vol *volume_info)
1596{
1597 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001598 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001599 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1600 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1601 int rc;
1602
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001603 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001604
Joe Perchesb6b38f72010-04-21 03:50:45 +00001605 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001606
Jeff Layton63c038c2008-12-01 18:41:46 -05001607 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton50d97162010-07-06 20:43:01 -04001608 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1609 volume_info->UNCip,
David Howells67b76262010-07-22 18:33:01 +01001610 strlen(volume_info->UNCip),
Jeff Layton50d97162010-07-06 20:43:01 -04001611 volume_info->port);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001612 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001613 /* we failed translating address */
1614 rc = -EINVAL;
1615 goto out_err;
1616 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001617 } else if (volume_info->UNCip) {
1618 /* BB using ip addr as tcp_ses name to connect to the
1619 DFS root below */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001620 cERROR(1, "Connecting to DFS root not implemented yet");
Jeff Layton63c038c2008-12-01 18:41:46 -05001621 rc = -EINVAL;
1622 goto out_err;
1623 } else /* which tcp_sess DFS root would we conect to */ {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001624 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1625 "unc=//192.168.1.100/public) specified");
Jeff Layton63c038c2008-12-01 18:41:46 -05001626 rc = -EINVAL;
1627 goto out_err;
1628 }
1629
1630 /* see if we already have a matching tcp_ses */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001631 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05001632 if (tcp_ses)
1633 return tcp_ses;
1634
1635 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1636 if (!tcp_ses) {
1637 rc = -ENOMEM;
1638 goto out_err;
1639 }
1640
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001641 rc = cifs_crypto_shash_allocate(tcp_ses);
1642 if (rc) {
1643 cERROR(1, "could not setup hash structures rc %d", rc);
1644 goto out_err;
1645 }
1646
Jeff Layton63c038c2008-12-01 18:41:46 -05001647 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1648 if (IS_ERR(tcp_ses->hostname)) {
1649 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001650 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001651 }
1652
1653 tcp_ses->noblocksnd = volume_info->noblocksnd;
1654 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00001655 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Jeff Layton63c038c2008-12-01 18:41:46 -05001656 atomic_set(&tcp_ses->inFlight, 0);
1657 init_waitqueue_head(&tcp_ses->response_q);
1658 init_waitqueue_head(&tcp_ses->request_q);
1659 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1660 mutex_init(&tcp_ses->srv_mutex);
1661 memcpy(tcp_ses->workstation_RFC1001_name,
1662 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1663 memcpy(tcp_ses->server_RFC1001_name,
1664 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05001665 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05001666 tcp_ses->sequence_number = 0;
1667 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1668 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1669
1670 /*
1671 * at this point we are the only ones with the pointer
1672 * to the struct since the kernel thread not created yet
1673 * no need to spinlock this init of tcpStatus or srv_count
1674 */
1675 tcp_ses->tcpStatus = CifsNew;
Ben Greear3eb9a882010-09-01 17:06:02 -07001676 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1677 sizeof(tcp_ses->srcaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05001678 ++tcp_ses->srv_count;
1679
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001680 if (addr.ss_family == AF_INET6) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001681 cFYI(1, "attempting ipv6 connect");
Jeff Layton63c038c2008-12-01 18:41:46 -05001682 /* BB should we allow ipv6 on port 139? */
1683 /* other OS never observed in Wild doing 139 with v6 */
1684 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1685 sizeof(struct sockaddr_in6));
Jeff Laytond5c56052008-12-01 18:42:33 -05001686 rc = ipv6_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001687 } else {
1688 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1689 sizeof(struct sockaddr_in));
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001690 rc = ipv4_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001691 }
1692 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001693 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001694 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001695 }
1696
1697 /*
1698 * since we're in a cifs function already, we know that
1699 * this will succeed. No need for try_module_get().
1700 */
1701 __module_get(THIS_MODULE);
1702 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1703 tcp_ses, "cifsd");
1704 if (IS_ERR(tcp_ses->tsk)) {
1705 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001706 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05001707 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001708 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001709 }
1710
1711 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301712 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001713 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301714 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001715
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301716 cifs_fscache_get_client_cookie(tcp_ses);
1717
Jeff Layton63c038c2008-12-01 18:41:46 -05001718 return tcp_ses;
1719
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001720out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001721 cifs_crypto_shash_release(tcp_ses);
1722
Jeff Layton63c038c2008-12-01 18:41:46 -05001723out_err:
1724 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00001725 if (!IS_ERR(tcp_ses->hostname))
1726 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05001727 if (tcp_ses->ssocket)
1728 sock_release(tcp_ses->ssocket);
1729 kfree(tcp_ses);
1730 }
1731 return ERR_PTR(rc);
1732}
1733
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734static struct cifsSesInfo *
Jeff Layton4ff67b72010-07-06 20:43:02 -04001735cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 struct cifsSesInfo *ses;
1738
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301739 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04001740 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1741 switch (server->secType) {
1742 case Kerberos:
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001743 if (vol->cred_uid != ses->cred_uid)
Jeff Layton4ff67b72010-07-06 20:43:02 -04001744 continue;
1745 break;
1746 default:
1747 /* anything else takes username/password */
1748 if (strncmp(ses->userName, vol->username,
1749 MAX_USERNAME_SIZE))
1750 continue;
1751 if (strlen(vol->username) != 0 &&
Jeff Layton24e6cf92010-08-23 11:38:04 -04001752 ses->password != NULL &&
Jeff Laytonfc87a402010-08-18 13:13:39 -04001753 strncmp(ses->password,
1754 vol->password ? vol->password : "",
Jeff Layton4ff67b72010-07-06 20:43:02 -04001755 MAX_PASSWORD_SIZE))
1756 continue;
1757 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001758 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301759 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001760 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301762 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 return NULL;
1764}
1765
Jeff Layton14fbf502008-11-14 13:53:46 -05001766static void
1767cifs_put_smb_ses(struct cifsSesInfo *ses)
1768{
1769 int xid;
1770 struct TCP_Server_Info *server = ses->server;
1771
Jeff Layton36988c72010-04-24 07:57:43 -04001772 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301773 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001774 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301775 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001776 return;
1777 }
1778
1779 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301780 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001781
1782 if (ses->status == CifsGood) {
1783 xid = GetXid();
1784 CIFSSMBLogoff(xid, ses);
1785 _FreeXid(xid);
1786 }
1787 sesInfoFree(ses);
1788 cifs_put_tcp_session(server);
1789}
1790
Jeff Layton36988c72010-04-24 07:57:43 -04001791static struct cifsSesInfo *
1792cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1793{
1794 int rc = -ENOMEM, xid;
1795 struct cifsSesInfo *ses;
1796
1797 xid = GetXid();
1798
Jeff Layton4ff67b72010-07-06 20:43:02 -04001799 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04001800 if (ses) {
1801 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1802
Jeff Layton36988c72010-04-24 07:57:43 -04001803 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001804 rc = cifs_negotiate_protocol(xid, ses);
1805 if (rc) {
1806 mutex_unlock(&ses->session_mutex);
1807 /* problem -- put our ses reference */
1808 cifs_put_smb_ses(ses);
1809 FreeXid(xid);
1810 return ERR_PTR(rc);
1811 }
Jeff Layton36988c72010-04-24 07:57:43 -04001812 if (ses->need_reconnect) {
1813 cFYI(1, "Session needs reconnect");
1814 rc = cifs_setup_session(xid, ses,
1815 volume_info->local_nls);
1816 if (rc) {
1817 mutex_unlock(&ses->session_mutex);
1818 /* problem -- put our reference */
1819 cifs_put_smb_ses(ses);
1820 FreeXid(xid);
1821 return ERR_PTR(rc);
1822 }
1823 }
1824 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04001825
1826 /* existing SMB ses has a server reference already */
1827 cifs_put_tcp_session(server);
Jeff Layton36988c72010-04-24 07:57:43 -04001828 FreeXid(xid);
1829 return ses;
1830 }
1831
1832 cFYI(1, "Existing smb sess not found");
1833 ses = sesInfoAlloc();
1834 if (ses == NULL)
1835 goto get_ses_fail;
1836
1837 /* new SMB session uses our server ref */
1838 ses->server = server;
1839 if (server->addr.sockAddr6.sin6_family == AF_INET6)
1840 sprintf(ses->serverName, "%pI6",
1841 &server->addr.sockAddr6.sin6_addr);
1842 else
1843 sprintf(ses->serverName, "%pI4",
1844 &server->addr.sockAddr.sin_addr.s_addr);
1845
1846 if (volume_info->username)
1847 strncpy(ses->userName, volume_info->username,
1848 MAX_USERNAME_SIZE);
1849
1850 /* volume_info->password freed at unmount */
1851 if (volume_info->password) {
1852 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1853 if (!ses->password)
1854 goto get_ses_fail;
1855 }
1856 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05001857 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1858 if (!ses->domainName)
1859 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04001860 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001861 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04001862 ses->linux_uid = volume_info->linux_uid;
1863 ses->overrideSecFlg = volume_info->secFlg;
1864
1865 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001866 rc = cifs_negotiate_protocol(xid, ses);
1867 if (!rc)
1868 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04001869 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00001870 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04001871 goto get_ses_fail;
1872
1873 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301874 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04001875 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301876 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04001877
1878 FreeXid(xid);
1879 return ses;
1880
1881get_ses_fail:
1882 sesInfoFree(ses);
1883 FreeXid(xid);
1884 return ERR_PTR(rc);
1885}
1886
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05001888cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889{
1890 struct list_head *tmp;
1891 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301893 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001894 list_for_each(tmp, &ses->tcon_list) {
1895 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1896 if (tcon->tidStatus == CifsExiting)
1897 continue;
1898 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 continue;
1900
Jeff Laytonf1987b42008-11-15 11:12:47 -05001901 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301902 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 return tcon;
1904 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301905 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 return NULL;
1907}
1908
Jeff Laytonf1987b42008-11-15 11:12:47 -05001909static void
1910cifs_put_tcon(struct cifsTconInfo *tcon)
1911{
1912 int xid;
1913 struct cifsSesInfo *ses = tcon->ses;
1914
Jeff Laytond00c28d2010-04-24 07:57:44 -04001915 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301916 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001917 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301918 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001919 return;
1920 }
1921
1922 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301923 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001924
1925 xid = GetXid();
1926 CIFSSMBTDis(xid, tcon);
1927 _FreeXid(xid);
1928
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301929 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00001930 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001931 cifs_put_smb_ses(ses);
1932}
1933
Jeff Laytond00c28d2010-04-24 07:57:44 -04001934static struct cifsTconInfo *
1935cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1936{
1937 int rc, xid;
1938 struct cifsTconInfo *tcon;
1939
1940 tcon = cifs_find_tcon(ses, volume_info->UNC);
1941 if (tcon) {
1942 cFYI(1, "Found match on UNC path");
1943 /* existing tcon already has a reference */
1944 cifs_put_smb_ses(ses);
1945 if (tcon->seal != volume_info->seal)
1946 cERROR(1, "transport encryption setting "
1947 "conflicts with existing tid");
1948 return tcon;
1949 }
1950
1951 tcon = tconInfoAlloc();
1952 if (tcon == NULL) {
1953 rc = -ENOMEM;
1954 goto out_fail;
1955 }
1956
1957 tcon->ses = ses;
1958 if (volume_info->password) {
1959 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
1960 if (!tcon->password) {
1961 rc = -ENOMEM;
1962 goto out_fail;
1963 }
1964 }
1965
1966 if (strchr(volume_info->UNC + 3, '\\') == NULL
1967 && strchr(volume_info->UNC + 3, '/') == NULL) {
1968 cERROR(1, "Missing share name");
1969 rc = -ENODEV;
1970 goto out_fail;
1971 }
1972
1973 /* BB Do we need to wrap session_mutex around
1974 * this TCon call and Unix SetFS as
1975 * we do on SessSetup and reconnect? */
1976 xid = GetXid();
1977 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
1978 FreeXid(xid);
1979 cFYI(1, "CIFS Tcon rc = %d", rc);
1980 if (rc)
1981 goto out_fail;
1982
1983 if (volume_info->nodfs) {
1984 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
1985 cFYI(1, "DFS disabled (%d)", tcon->Flags);
1986 }
1987 tcon->seal = volume_info->seal;
1988 /* we can have only one retry value for a connection
1989 to a share so for resources mounted more than once
1990 to the same server share the last value passed in
1991 for the retry flag is used */
1992 tcon->retry = volume_info->retry;
1993 tcon->nocase = volume_info->nocase;
1994 tcon->local_lease = volume_info->local_lease;
1995
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301996 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04001997 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301998 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04001999
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302000 cifs_fscache_get_super_cookie(tcon);
2001
Jeff Laytond00c28d2010-04-24 07:57:44 -04002002 return tcon;
2003
2004out_fail:
2005 tconInfoFree(tcon);
2006 return ERR_PTR(rc);
2007}
2008
Jeff Layton9d002df2010-10-06 19:51:11 -04002009void
2010cifs_put_tlink(struct tcon_link *tlink)
2011{
2012 if (!tlink || IS_ERR(tlink))
2013 return;
2014
2015 if (!atomic_dec_and_test(&tlink->tl_count) ||
2016 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2017 tlink->tl_time = jiffies;
2018 return;
2019 }
2020
2021 if (!IS_ERR(tlink_tcon(tlink)))
2022 cifs_put_tcon(tlink_tcon(tlink));
2023 kfree(tlink);
2024 return;
2025}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002026
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027int
Steve French50c2f752007-07-13 00:33:32 +00002028get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2029 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00002030 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031{
2032 char *temp_unc;
2033 int rc = 0;
2034
2035 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00002036 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037
2038 if (pSesInfo->ipc_tid == 0) {
2039 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00002040 strnlen(pSesInfo->serverName,
2041 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 + 1 + 4 /* slash IPC$ */ + 2,
2043 GFP_KERNEL);
2044 if (temp_unc == NULL)
2045 return -ENOMEM;
2046 temp_unc[0] = '\\';
2047 temp_unc[1] = '\\';
2048 strcpy(temp_unc + 2, pSesInfo->serverName);
2049 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2050 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002051 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 kfree(temp_unc);
2053 }
2054 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00002055 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07002056 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00002057 /* BB map targetUNCs to dfs_info3 structures, here or
2058 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059
2060 return rc;
2061}
2062
Jeff Layton09e50d52008-07-23 10:11:19 -04002063#ifdef CONFIG_DEBUG_LOCK_ALLOC
2064static struct lock_class_key cifs_key[2];
2065static struct lock_class_key cifs_slock_key[2];
2066
2067static inline void
2068cifs_reclassify_socket4(struct socket *sock)
2069{
2070 struct sock *sk = sock->sk;
2071 BUG_ON(sock_owned_by_user(sk));
2072 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2073 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2074}
2075
2076static inline void
2077cifs_reclassify_socket6(struct socket *sock)
2078{
2079 struct sock *sk = sock->sk;
2080 BUG_ON(sock_owned_by_user(sk));
2081 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2082 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2083}
2084#else
2085static inline void
2086cifs_reclassify_socket4(struct socket *sock)
2087{
2088}
2089
2090static inline void
2091cifs_reclassify_socket6(struct socket *sock)
2092{
2093}
2094#endif
2095
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002097static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098{
Steve French50c2f752007-07-13 00:33:32 +00002099 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100
Steve French50c2f752007-07-13 00:33:32 +00002101 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 /* mask a nibble at a time and encode */
2103 target[j] = 'A' + (0x0F & (source[i] >> 4));
2104 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002105 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 }
2107
2108}
2109
Ben Greear3eb9a882010-09-01 17:06:02 -07002110static int
2111bind_socket(struct TCP_Server_Info *server)
2112{
2113 int rc = 0;
2114 if (server->srcaddr.ss_family != AF_UNSPEC) {
2115 /* Bind to the specified local IP address */
2116 struct socket *socket = server->ssocket;
2117 rc = socket->ops->bind(socket,
2118 (struct sockaddr *) &server->srcaddr,
2119 sizeof(server->srcaddr));
2120 if (rc < 0) {
2121 struct sockaddr_in *saddr4;
2122 struct sockaddr_in6 *saddr6;
2123 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2124 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2125 if (saddr6->sin6_family == AF_INET6)
2126 cERROR(1, "cifs: "
2127 "Failed to bind to: %pI6c, error: %d\n",
2128 &saddr6->sin6_addr, rc);
2129 else
2130 cERROR(1, "cifs: "
2131 "Failed to bind to: %pI4, error: %d\n",
2132 &saddr4->sin_addr.s_addr, rc);
2133 }
2134 }
2135 return rc;
2136}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
2138static int
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002139ipv4_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140{
2141 int rc = 0;
Steve French6a5fa2362010-01-01 01:28:43 +00002142 int val;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002143 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 __be16 orig_port = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002145 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002147 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002148 rc = sock_create_kern(PF_INET, SOCK_STREAM,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002149 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002151 cERROR(1, "Error %d creating socket", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002154
2155 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002156 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002157 server->ssocket = socket;
2158 socket->sk->sk_allocation = GFP_NOFS;
2159 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 }
2161
Ben Greear3eb9a882010-09-01 17:06:02 -07002162 rc = bind_socket(server);
2163 if (rc < 0)
2164 return rc;
2165
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002166 /* user overrode default port */
2167 if (server->addr.sockAddr.sin_port) {
2168 rc = socket->ops->connect(socket, (struct sockaddr *)
2169 &server->addr.sockAddr,
2170 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002172 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00002173 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002175 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00002176 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 later if fall back ports fail this time */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002178 orig_port = server->addr.sockAddr.sin_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
2180 /* do not retry on the same port we just failed on */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002181 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
2182 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
2183 rc = socket->ops->connect(socket,
2184 (struct sockaddr *)
2185 &server->addr.sockAddr,
2186 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002188 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 }
2190 }
2191 if (!connected) {
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002192 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
2193 rc = socket->ops->connect(socket, (struct sockaddr *)
2194 &server->addr.sockAddr,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002195 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00002196 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002197 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 }
2199
2200 /* give up here - unless we want to retry on different
2201 protocol families some day */
2202 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002203 if (orig_port)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002204 server->addr.sockAddr.sin_port = orig_port;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002205 cFYI(1, "Error %d connecting to server via ipv4", rc);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002206 sock_release(socket);
2207 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 return rc;
2209 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002210
2211
2212 /*
2213 * Eventually check for other socket options to change from
2214 * the default. sock_setsockopt not used because it expects
2215 * user space buffer
2216 */
2217 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002218 socket->sk->sk_sndtimeo = 5 * HZ;
Steve Frenchedf1ae42008-10-29 00:47:57 +00002219
Steve Frenchb387eae2005-10-10 14:21:15 -07002220 /* make the bufsizes depend on wsize/rsize and max requests */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002221 if (server->noautotune) {
2222 if (socket->sk->sk_sndbuf < (200 * 1024))
2223 socket->sk->sk_sndbuf = 200 * 1024;
2224 if (socket->sk->sk_rcvbuf < (140 * 1024))
2225 socket->sk->sk_rcvbuf = 140 * 1024;
Steve Frenchedf1ae42008-10-29 00:47:57 +00002226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227
Steve French6a5fa2362010-01-01 01:28:43 +00002228 if (server->tcp_nodelay) {
2229 val = 1;
2230 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2231 (char *)&val, sizeof(val));
2232 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002233 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002234 }
2235
Joe Perchesb6b38f72010-04-21 03:50:45 +00002236 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002237 socket->sk->sk_sndbuf,
Joe Perchesb6b38f72010-04-21 03:50:45 +00002238 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002239
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 /* send RFC1001 sessinit */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002241 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00002243 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00002245 struct rfc1002_session_packet *ses_init_buf;
2246 struct smb_hdr *smb_buf;
2247 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2248 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002249 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 ses_init_buf->trailer.session_req.called_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002251 if (server->server_RFC1001_name &&
2252 server->server_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05002253 rfc1002mangle(ses_init_buf->trailer.
2254 session_req.called_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002255 server->server_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05002256 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002257 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05002258 rfc1002mangle(ses_init_buf->trailer.
2259 session_req.called_name,
2260 DEFAULT_CIFS_CALLED_NAME,
2261 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07002262
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 ses_init_buf->trailer.session_req.calling_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002264
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 /* calling name ends in null (byte 16) from old smb
2266 convention. */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002267 if (server->workstation_RFC1001_name &&
2268 server->workstation_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05002269 rfc1002mangle(ses_init_buf->trailer.
2270 session_req.calling_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002271 server->workstation_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05002272 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002273 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05002274 rfc1002mangle(ses_init_buf->trailer.
2275 session_req.calling_name,
2276 "LINUX_CIFS_CLNT",
2277 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 ses_init_buf->trailer.session_req.scope1 = 0;
2280 ses_init_buf->trailer.session_req.scope2 = 0;
2281 smb_buf = (struct smb_hdr *)ses_init_buf;
2282 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2283 smb_buf->smb_buf_length = 0x81000044;
Jeff Layton0496e022008-12-30 12:39:16 -05002284 rc = smb_send(server, smb_buf, 0x44);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00002286 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00002287 requires very short break before negprot
2288 presumably because not expecting negprot
2289 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00002290 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00002291 complicating the code and causes no
2292 significant slowing down on mount
2293 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 }
Steve French50c2f752007-07-13 00:33:32 +00002295 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00002297
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 }
Steve French50c2f752007-07-13 00:33:32 +00002299
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 return rc;
2301}
2302
2303static int
Jeff Laytond5c56052008-12-01 18:42:33 -05002304ipv6_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305{
2306 int rc = 0;
Steve French6a5fa2362010-01-01 01:28:43 +00002307 int val;
Jeff Laytond5c56052008-12-01 18:42:33 -05002308 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 __be16 orig_port = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05002310 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311
Jeff Laytond5c56052008-12-01 18:42:33 -05002312 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002313 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
Jeff Laytond5c56052008-12-01 18:42:33 -05002314 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002316 cERROR(1, "Error %d creating ipv6 socket", rc);
Jeff Laytond5c56052008-12-01 18:42:33 -05002317 socket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 }
Jeff Laytond5c56052008-12-01 18:42:33 -05002320
2321 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002322 cFYI(1, "ipv6 Socket created");
Jeff Laytond5c56052008-12-01 18:42:33 -05002323 server->ssocket = socket;
2324 socket->sk->sk_allocation = GFP_NOFS;
2325 cifs_reclassify_socket6(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 }
2327
Ben Greear3eb9a882010-09-01 17:06:02 -07002328 rc = bind_socket(server);
2329 if (rc < 0)
2330 return rc;
2331
Jeff Laytond5c56052008-12-01 18:42:33 -05002332 /* user overrode default port */
2333 if (server->addr.sockAddr6.sin6_port) {
2334 rc = socket->ops->connect(socket,
2335 (struct sockaddr *) &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002336 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05002338 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00002339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002341 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00002342 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 later if fall back ports fail this time */
2344
Jeff Laytond5c56052008-12-01 18:42:33 -05002345 orig_port = server->addr.sockAddr6.sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 /* do not retry on the same port we just failed on */
Jeff Laytond5c56052008-12-01 18:42:33 -05002347 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
2348 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
2349 rc = socket->ops->connect(socket, (struct sockaddr *)
2350 &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002351 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05002353 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 }
2355 }
2356 if (!connected) {
Jeff Laytond5c56052008-12-01 18:42:33 -05002357 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
2358 rc = socket->ops->connect(socket, (struct sockaddr *)
2359 &server->addr.sockAddr6,
2360 sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00002361 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05002362 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 }
2364
2365 /* give up here - unless we want to retry on different
2366 protocol families some day */
2367 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002368 if (orig_port)
Jeff Laytond5c56052008-12-01 18:42:33 -05002369 server->addr.sockAddr6.sin6_port = orig_port;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002370 cFYI(1, "Error %d connecting to server via ipv6", rc);
Jeff Laytond5c56052008-12-01 18:42:33 -05002371 sock_release(socket);
2372 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 return rc;
2374 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00002375
Jeff Laytond5c56052008-12-01 18:42:33 -05002376 /*
2377 * Eventually check for other socket options to change from
2378 * the default. sock_setsockopt not used because it expects
2379 * user space buffer
2380 */
2381 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002382 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00002383
2384 if (server->tcp_nodelay) {
2385 val = 1;
2386 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2387 (char *)&val, sizeof(val));
2388 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002389 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002390 }
2391
Jeff Laytond5c56052008-12-01 18:42:33 -05002392 server->ssocket = socket;
Steve French50c2f752007-07-13 00:33:32 +00002393
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 return rc;
2395}
2396
Steve French50c2f752007-07-13 00:33:32 +00002397void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2398 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00002399{
2400 /* if we are reconnecting then should we check to see if
2401 * any requested capabilities changed locally e.g. via
2402 * remount but we can not do much about it here
2403 * if they have (even if we could detect it by the following)
2404 * Perhaps we could add a backpointer to array of sb from tcon
2405 * or if we change to make all sb to same share the same
2406 * sb as NFS - then we only have one backpointer to sb.
2407 * What if we wanted to mount the server share twice once with
2408 * and once without posixacls or posix paths? */
2409 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002410
Steve Frenchc18c8422007-07-18 23:21:09 +00002411 if (vol_info && vol_info->no_linux_ext) {
2412 tcon->fsUnixInfo.Capability = 0;
2413 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002414 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00002415 return;
2416 } else if (vol_info)
2417 tcon->unix_ext = 1; /* Unix Extensions supported */
2418
2419 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002420 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00002421 return;
2422 }
Steve French50c2f752007-07-13 00:33:32 +00002423
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002424 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00002425 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002426
Steve French8af18972007-02-14 04:42:51 +00002427 /* check for reconnect case in which we do not
2428 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002429 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002430 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002431 originally at mount time */
2432 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2433 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002434 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2435 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002436 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00002437 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002438 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002439 cERROR(1, "possible reconnect error");
2440 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00002441 }
Steve French8af18972007-02-14 04:42:51 +00002442 }
Steve French50c2f752007-07-13 00:33:32 +00002443
Steve French8af18972007-02-14 04:42:51 +00002444 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002445 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002446 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002447 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002448 cFYI(1, "negotiated posix acl support");
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002449 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002450 sb->s_flags |= MS_POSIXACL;
2451 }
2452
Steve French75865f8c2007-06-24 18:30:48 +00002453 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002454 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002455 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002456 cFYI(1, "negotiate posix pathnames");
Steve French75865f8c2007-06-24 18:30:48 +00002457 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002458 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002459 CIFS_MOUNT_POSIX_PATHS;
2460 }
Steve French50c2f752007-07-13 00:33:32 +00002461
Steve French984acfe2007-04-26 16:42:50 +00002462 /* We might be setting the path sep back to a different
2463 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002464 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002465 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002466 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002467
2468 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2469 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2470 CIFS_SB(sb)->rsize = 127 * 1024;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002471 cFYI(DBG2, "larger reads not supported by srv");
Steve French75865f8c2007-06-24 18:30:48 +00002472 }
2473 }
Steve French50c2f752007-07-13 00:33:32 +00002474
2475
Joe Perchesb6b38f72010-04-21 03:50:45 +00002476 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00002477#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002478 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002479 cFYI(1, "FCNTL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002480 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002481 cFYI(1, "EXTATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002482 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002483 cFYI(1, "POSIX path cap");
Steve French75865f8c2007-06-24 18:30:48 +00002484 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002485 cFYI(1, "XATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002486 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002487 cFYI(1, "POSIX ACL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002488 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002489 cFYI(1, "very large read cap");
Steve French75865f8c2007-06-24 18:30:48 +00002490 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002491 cFYI(1, "very large write cap");
Steve French8af18972007-02-14 04:42:51 +00002492#endif /* CIFS_DEBUG2 */
2493 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002494 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002495 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00002496 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002497 cERROR(1, "Negotiating Unix capabilities "
Steve French5a44b312007-09-20 15:16:24 +00002498 "with the server failed. Consider "
2499 "mounting with the Unix Extensions\n"
2500 "disabled, if problems are found, "
2501 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00002502 "option.");
Steve French5a44b312007-09-20 15:16:24 +00002503
Steve French8af18972007-02-14 04:42:51 +00002504 }
2505 }
2506}
2507
Steve French03a143c2008-02-14 06:38:30 +00002508static void
2509convert_delimiter(char *path, char delim)
2510{
2511 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002512 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002513
2514 if (path == NULL)
2515 return;
2516
Steve French582d21e2008-05-13 04:54:12 +00002517 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002518 old_delim = '\\';
2519 else
2520 old_delim = '/';
2521
Steve French03a143c2008-02-14 06:38:30 +00002522 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002523 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002524 path[i] = delim;
2525 }
2526}
2527
Steve French3b795212008-11-13 19:45:32 +00002528static void setup_cifs_sb(struct smb_vol *pvolume_info,
2529 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002530{
Jeff Layton2de970f2010-10-06 19:51:12 -04002531 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2532
Steve French3b795212008-11-13 19:45:32 +00002533 if (pvolume_info->rsize > CIFSMaxBufSize) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002534 cERROR(1, "rsize %d too large, using MaxBufSize",
2535 pvolume_info->rsize);
Steve French3b795212008-11-13 19:45:32 +00002536 cifs_sb->rsize = CIFSMaxBufSize;
2537 } else if ((pvolume_info->rsize) &&
2538 (pvolume_info->rsize <= CIFSMaxBufSize))
2539 cifs_sb->rsize = pvolume_info->rsize;
2540 else /* default */
2541 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002542
Steve French3b795212008-11-13 19:45:32 +00002543 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002544 cERROR(1, "wsize %d too large, using 4096 instead",
2545 pvolume_info->wsize);
Steve French3b795212008-11-13 19:45:32 +00002546 cifs_sb->wsize = 4096;
2547 } else if (pvolume_info->wsize)
2548 cifs_sb->wsize = pvolume_info->wsize;
2549 else
2550 cifs_sb->wsize = min_t(const int,
2551 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2552 127*1024);
2553 /* old default of CIFSMaxBufSize was too small now
2554 that SMB Write2 can send multiple pages in kvec.
2555 RFC1001 does not describe what happens when frame
2556 bigger than 128K is sent so use that as max in
2557 conjunction with 52K kvec constraint on arch with 4K
2558 page size */
2559
2560 if (cifs_sb->rsize < 2048) {
2561 cifs_sb->rsize = 2048;
2562 /* Windows ME may prefer this */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002563 cFYI(1, "readsize set to minimum: 2048");
Steve French3b795212008-11-13 19:45:32 +00002564 }
2565 /* calculate prepath */
2566 cifs_sb->prepath = pvolume_info->prepath;
2567 if (cifs_sb->prepath) {
2568 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2569 /* we can not convert the / to \ in the path
2570 separators in the prefixpath yet because we do not
2571 know (until reset_cifs_unix_caps is called later)
2572 whether POSIX PATH CAP is available. We normalize
2573 the / to \ after reset_cifs_unix_caps is called */
2574 pvolume_info->prepath = NULL;
2575 } else
2576 cifs_sb->prepathlen = 0;
2577 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2578 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2579 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2580 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002581 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2582 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00002583
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302584 cifs_sb->actimeo = pvolume_info->actimeo;
2585
Steve French3b795212008-11-13 19:45:32 +00002586 if (pvolume_info->noperm)
2587 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2588 if (pvolume_info->setuids)
2589 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2590 if (pvolume_info->server_ino)
2591 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2592 if (pvolume_info->remap)
2593 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2594 if (pvolume_info->no_xattr)
2595 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2596 if (pvolume_info->sfu_emul)
2597 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2598 if (pvolume_info->nobrl)
2599 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002600 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002601 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002602 if (pvolume_info->mand_lock)
2603 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002604 if (pvolume_info->cifs_acl)
2605 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2606 if (pvolume_info->override_uid)
2607 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2608 if (pvolume_info->override_gid)
2609 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2610 if (pvolume_info->dynperm)
2611 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05302612 if (pvolume_info->fsc)
2613 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04002614 if (pvolume_info->multiuser)
2615 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2616 CIFS_MOUNT_NO_PERM);
Steve French3b795212008-11-13 19:45:32 +00002617 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002618 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00002619 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2620 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02002621 if (pvolume_info->mfsymlinks) {
2622 if (pvolume_info->sfu_emul) {
2623 cERROR(1, "mount option mfsymlinks ignored if sfu "
2624 "mount option is used");
2625 } else {
2626 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2627 }
2628 }
Steve French3b795212008-11-13 19:45:32 +00002629
2630 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00002631 cERROR(1, "mount option dynperm ignored if cifsacl "
2632 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002633}
2634
Igor Mammedove4cce942009-02-10 14:10:26 +03002635static int
2636is_path_accessible(int xid, struct cifsTconInfo *tcon,
2637 struct cifs_sb_info *cifs_sb, const char *full_path)
2638{
2639 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03002640 FILE_ALL_INFO *pfile_info;
2641
Igor Mammedove4cce942009-02-10 14:10:26 +03002642 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2643 if (pfile_info == NULL)
2644 return -ENOMEM;
2645
2646 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2647 0 /* not legacy */, cifs_sb->local_nls,
2648 cifs_sb->mnt_cifs_flags &
2649 CIFS_MOUNT_MAP_SPECIAL_CHR);
2650 kfree(pfile_info);
2651 return rc;
2652}
2653
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002654static void
2655cleanup_volume_info(struct smb_vol **pvolume_info)
2656{
2657 struct smb_vol *volume_info;
2658
Dan Carpenterad6cca62010-04-26 12:10:06 +02002659 if (!pvolume_info || !*pvolume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002660 return;
2661
2662 volume_info = *pvolume_info;
2663 kzfree(volume_info->password);
2664 kfree(volume_info->UNC);
2665 kfree(volume_info->prepath);
2666 kfree(volume_info);
2667 *pvolume_info = NULL;
2668 return;
2669}
2670
Steve French2d6d5892009-04-09 00:36:44 +00002671#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002672/* build_path_to_root returns full path to root when
2673 * we do not have an exiting connection (tcon) */
2674static char *
2675build_unc_path_to_root(const struct smb_vol *volume_info,
2676 const struct cifs_sb_info *cifs_sb)
2677{
2678 char *full_path;
2679
2680 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2681 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2682 if (full_path == NULL)
2683 return ERR_PTR(-ENOMEM);
2684
2685 strncpy(full_path, volume_info->UNC, unc_len);
2686 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2687 int i;
2688 for (i = 0; i < unc_len; i++) {
2689 if (full_path[i] == '\\')
2690 full_path[i] = '/';
2691 }
2692 }
2693
2694 if (cifs_sb->prepathlen)
2695 strncpy(full_path + unc_len, cifs_sb->prepath,
2696 cifs_sb->prepathlen);
2697
2698 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2699 return full_path;
2700}
Steve French2d6d5892009-04-09 00:36:44 +00002701#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002702
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703int
2704cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002705 char *mount_data_global, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706{
Jeff Laytona2934c72009-12-03 08:09:41 -05002707 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002709 struct smb_vol *volume_info;
Jeff Laytona2934c72009-12-03 08:09:41 -05002710 struct cifsSesInfo *pSesInfo;
2711 struct cifsTconInfo *tcon;
2712 struct TCP_Server_Info *srvTcp;
Igor Mammedove4cce942009-02-10 14:10:26 +03002713 char *full_path;
Steve French2d6d5892009-04-09 00:36:44 +00002714 char *mount_data = mount_data_global;
Jeff Layton9d002df2010-10-06 19:51:11 -04002715 struct tcon_link *tlink;
Steve French2d6d5892009-04-09 00:36:44 +00002716#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002717 struct dfs_info3_param *referrals = NULL;
2718 unsigned int num_referrals = 0;
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002719 int referral_walks_count = 0;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002720try_mount_again:
Steve French2d6d5892009-04-09 00:36:44 +00002721#endif
Jeff Laytona2934c72009-12-03 08:09:41 -05002722 rc = 0;
2723 tcon = NULL;
2724 pSesInfo = NULL;
2725 srvTcp = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002726 full_path = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04002727 tlink = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728
2729 xid = GetXid();
2730
Jeff Layton7586b762008-12-01 18:41:49 -05002731 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2732 if (!volume_info) {
2733 rc = -ENOMEM;
2734 goto out;
2735 }
Steve French50c2f752007-07-13 00:33:32 +00002736
Jeff Layton7586b762008-12-01 18:41:49 -05002737 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002738 rc = -EINVAL;
2739 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740 }
2741
Jeff Layton7586b762008-12-01 18:41:49 -05002742 if (volume_info->nullauth) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002743 cFYI(1, "null user");
Jeff Layton7586b762008-12-01 18:41:49 -05002744 volume_info->username = "";
2745 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002747 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002749 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002750 /* In userspace mount helper we can get user name from alternate
2751 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002752 rc = -EINVAL;
2753 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 }
2755
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002757 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002758 /* load_nls_default cannot return null */
2759 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002761 volume_info->local_nls = load_nls(volume_info->iocharset);
2762 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002763 cERROR(1, "CIFS mount error: iocharset %s not found",
2764 volume_info->iocharset);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002765 rc = -ELIBACC;
2766 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 }
2768 }
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002769 cifs_sb->local_nls = volume_info->local_nls;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770
Jeff Layton63c038c2008-12-01 18:41:46 -05002771 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002772 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002773 if (IS_ERR(srvTcp)) {
2774 rc = PTR_ERR(srvTcp);
2775 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 }
2777
Jeff Layton36988c72010-04-24 07:57:43 -04002778 /* get a reference to a SMB session */
2779 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2780 if (IS_ERR(pSesInfo)) {
2781 rc = PTR_ERR(pSesInfo);
2782 pSesInfo = NULL;
2783 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 }
Steve French50c2f752007-07-13 00:33:32 +00002785
Jeff Laytond00c28d2010-04-24 07:57:44 -04002786 setup_cifs_sb(volume_info, cifs_sb);
2787 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2788 sb->s_maxbytes = MAX_LFS_FILESIZE;
2789 else
2790 sb->s_maxbytes = MAX_NON_LFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791
Steve French8af18972007-02-14 04:42:51 +00002792 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 sb->s_time_gran = 100;
2794
Jeff Laytond00c28d2010-04-24 07:57:44 -04002795 /* search for existing tcon to this server share */
2796 tcon = cifs_get_tcon(pSesInfo, volume_info);
2797 if (IS_ERR(tcon)) {
2798 rc = PTR_ERR(tcon);
2799 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002800 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002801 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002802
Steve Frenchd82c2df2008-11-15 00:07:26 +00002803 /* do not care if following two calls succeed - informational */
2804 if (!tcon->ipc) {
2805 CIFSSMBQFSDeviceInfo(xid, tcon);
2806 CIFSSMBQFSAttributeInfo(xid, tcon);
2807 }
2808
2809 /* tell server which Unix caps we support */
2810 if (tcon->ses->capabilities & CAP_UNIX)
2811 /* reset of caps checks mount to see if unix extensions
2812 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002813 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002814 else
2815 tcon->unix_ext = 0; /* server does not support them */
2816
2817 /* convert forward to back slashes in prepath here if needed */
2818 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2819 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2820
2821 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2822 cifs_sb->rsize = 1024 * 127;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002823 cFYI(DBG2, "no very large read support, rsize now 127K");
Steve Frenchd82c2df2008-11-15 00:07:26 +00002824 }
2825 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2826 cifs_sb->wsize = min(cifs_sb->wsize,
2827 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2828 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2829 cifs_sb->rsize = min(cifs_sb->rsize,
2830 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002832remote_path_check:
2833 /* check if a whole path (including prepath) is not remote */
2834 if (!rc && cifs_sb->prepathlen && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002835 /* build_path_to_root works only when we have a valid tcon */
Jeff Layton7d161b72010-12-07 02:10:35 -05002836 full_path = cifs_build_path_to_root(cifs_sb, tcon);
Igor Mammedove4cce942009-02-10 14:10:26 +03002837 if (full_path == NULL) {
2838 rc = -ENOMEM;
2839 goto mount_fail_check;
2840 }
2841 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Jeff Layton03ceace2010-12-06 21:07:33 -05002842 if (rc != 0 && rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002843 kfree(full_path);
2844 goto mount_fail_check;
2845 }
2846 kfree(full_path);
2847 }
2848
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002849 /* get referral if needed */
2850 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00002851#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002852 if (referral_walks_count > MAX_NESTED_LINKS) {
2853 /*
2854 * BB: when we implement proper loop detection,
2855 * we will remove this check. But now we need it
2856 * to prevent an indefinite loop if 'DFS tree' is
2857 * misconfigured (i.e. has loops).
2858 */
2859 rc = -ELOOP;
2860 goto mount_fail_check;
2861 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002862 /* convert forward to back slashes in prepath here if needed */
2863 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2864 convert_delimiter(cifs_sb->prepath,
2865 CIFS_DIR_SEP(cifs_sb));
2866 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2867 if (IS_ERR(full_path)) {
2868 rc = PTR_ERR(full_path);
2869 goto mount_fail_check;
2870 }
2871
Joe Perchesb6b38f72010-04-21 03:50:45 +00002872 cFYI(1, "Getting referral for: %s", full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002873 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2874 cifs_sb->local_nls, &num_referrals, &referrals,
2875 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2876 if (!rc && num_referrals > 0) {
2877 char *fake_devname = NULL;
2878
2879 if (mount_data != mount_data_global)
2880 kfree(mount_data);
Jeff Layton7b91e262009-07-23 15:22:30 -04002881
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002882 mount_data = cifs_compose_mount_options(
2883 cifs_sb->mountdata, full_path + 1,
2884 referrals, &fake_devname);
Jeff Layton7b91e262009-07-23 15:22:30 -04002885
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002886 free_dfs_info_array(referrals, num_referrals);
Jeff Layton7b91e262009-07-23 15:22:30 -04002887 kfree(fake_devname);
2888 kfree(full_path);
2889
2890 if (IS_ERR(mount_data)) {
2891 rc = PTR_ERR(mount_data);
2892 mount_data = NULL;
2893 goto mount_fail_check;
2894 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002895
2896 if (tcon)
2897 cifs_put_tcon(tcon);
2898 else if (pSesInfo)
2899 cifs_put_smb_ses(pSesInfo);
2900
2901 cleanup_volume_info(&volume_info);
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002902 referral_walks_count++;
Jeff Laytona2934c72009-12-03 08:09:41 -05002903 FreeXid(xid);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002904 goto try_mount_again;
2905 }
Steve Frenchd036f502009-04-03 03:12:08 +00002906#else /* No DFS support, return error on mount */
2907 rc = -EOPNOTSUPP;
2908#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002909 }
2910
Jeff Layton9d002df2010-10-06 19:51:11 -04002911 if (rc)
2912 goto mount_fail_check;
2913
2914 /* now, hang the tcon off of the superblock */
2915 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2916 if (tlink == NULL) {
2917 rc = -ENOMEM;
2918 goto mount_fail_check;
2919 }
2920
Jeff Laytonb647c352010-10-28 11:16:44 -04002921 tlink->tl_uid = pSesInfo->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04002922 tlink->tl_tcon = tcon;
2923 tlink->tl_time = jiffies;
2924 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2925 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2926
Jeff Layton413e6612010-10-28 13:33:38 -04002927 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04002928 spin_lock(&cifs_sb->tlink_tree_lock);
2929 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2930 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04002931
Jeff Layton2de970f2010-10-06 19:51:12 -04002932 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2933 TLINK_IDLE_EXPIRE);
2934
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002935mount_fail_check:
2936 /* on error free sesinfo and tcon struct if needed */
2937 if (rc) {
2938 if (mount_data != mount_data_global)
2939 kfree(mount_data);
2940 /* If find_unc succeeded then rc == 0 so we can not end */
2941 /* up accidently freeing someone elses tcon struct */
2942 if (tcon)
2943 cifs_put_tcon(tcon);
2944 else if (pSesInfo)
2945 cifs_put_smb_ses(pSesInfo);
2946 else
2947 cifs_put_tcp_session(srvTcp);
2948 goto out;
2949 }
2950
Jeff Layton7586b762008-12-01 18:41:49 -05002951 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952 (in which case it is not needed anymore) but when new sesion is created
2953 the password ptr is put in the new session structure (in which case the
2954 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002955out:
2956 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002957 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 FreeXid(xid);
2959 return rc;
2960}
2961
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962int
2963CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2964 const char *tree, struct cifsTconInfo *tcon,
2965 const struct nls_table *nls_codepage)
2966{
2967 struct smb_hdr *smb_buffer;
2968 struct smb_hdr *smb_buffer_response;
2969 TCONX_REQ *pSMB;
2970 TCONX_RSP *pSMBr;
2971 unsigned char *bcc_ptr;
2972 int rc = 0;
Jeff Laytoncc20c032009-04-30 07:16:21 -04002973 int length, bytes_left;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974 __u16 count;
2975
2976 if (ses == NULL)
2977 return -EIO;
2978
2979 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00002980 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00002982
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 smb_buffer_response = smb_buffer;
2984
2985 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2986 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07002987
2988 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 smb_buffer->Uid = ses->Suid;
2990 pSMB = (TCONX_REQ *) smb_buffer;
2991 pSMBr = (TCONX_RSP *) smb_buffer_response;
2992
2993 pSMB->AndXCommand = 0xFF;
2994 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002996 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08002997 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00002998 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08002999 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003000 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003001 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00003002 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003003 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3004 specified as required (when that support is added to
3005 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003006 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003007 by Samba (not sure whether other servers allow
3008 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003009#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003010 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003011 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003012 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003013 ses->server->secMode &
3014 SECMODE_PW_ENCRYPT ? true : false,
3015 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003016 else
3017#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003018 SMBNTencrypt(tcon->password, ses->server->cryptkey, bcc_ptr);
Steve Frencheeac8042006-01-13 21:34:58 -08003019
Steve French7c7b25b2006-06-01 19:20:10 +00003020 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003021 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003022 /* must align unicode strings */
3023 *bcc_ptr = 0; /* null byte password */
3024 bcc_ptr++;
3025 }
Steve Frencheeac8042006-01-13 21:34:58 -08003026 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027
Steve French50c2f752007-07-13 00:33:32 +00003028 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003029 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3031
3032 if (ses->capabilities & CAP_STATUS32) {
3033 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3034 }
3035 if (ses->capabilities & CAP_DFS) {
3036 smb_buffer->Flags2 |= SMBFLG2_DFS;
3037 }
3038 if (ses->capabilities & CAP_UNICODE) {
3039 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3040 length =
Steve French50c2f752007-07-13 00:33:32 +00003041 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3042 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003043 (/* server len*/ + 256 /* share len */), nls_codepage);
3044 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 bcc_ptr += 2; /* skip trailing null */
3046 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047 strcpy(bcc_ptr, tree);
3048 bcc_ptr += strlen(tree) + 1;
3049 }
3050 strcpy(bcc_ptr, "?????");
3051 bcc_ptr += strlen("?????");
3052 bcc_ptr += 1;
3053 count = bcc_ptr - &pSMB->Password[0];
3054 pSMB->hdr.smb_buf_length += count;
3055 pSMB->ByteCount = cpu_to_le16(count);
3056
Steve French133672e2007-11-13 22:41:37 +00003057 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3058 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060 /* above now done in SendReceive */
3061 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003062 bool is_unicode;
3063
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003065 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066 tcon->tid = smb_buffer_response->Tid;
3067 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003068 bytes_left = BCC(smb_buffer_response);
3069 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003070 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3071 is_unicode = true;
3072 else
3073 is_unicode = false;
3074
Jeff Laytoncc20c032009-04-30 07:16:21 -04003075
Steve French50c2f752007-07-13 00:33:32 +00003076 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003077 if (length == 3) {
3078 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3079 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003080 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003081 tcon->ipc = 1;
3082 }
3083 } else if (length == 2) {
3084 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3085 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003086 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003087 }
3088 }
Steve French50c2f752007-07-13 00:33:32 +00003089 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003090 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003092
3093 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003094 kfree(tcon->nativeFileSystem);
Steve Frenchd185cda2009-04-30 17:45:10 +00003095 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003096 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003097 nls_codepage);
3098
Joe Perchesb6b38f72010-04-21 03:50:45 +00003099 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003100
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003101 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003102 (smb_buffer_response->WordCount == 7))
3103 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003104 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3105 else
3106 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003107 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003109 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110 ses->ipc_tid = smb_buffer_response->Tid;
3111 }
3112
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003113 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 return rc;
3115}
3116
3117int
3118cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3119{
Jeff Laytonb647c352010-10-28 11:16:44 -04003120 struct rb_root *root = &cifs_sb->tlink_tree;
3121 struct rb_node *node;
3122 struct tcon_link *tlink;
Steve French50c2f752007-07-13 00:33:32 +00003123 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124
Jeff Layton2de970f2010-10-06 19:51:12 -04003125 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3126
Jeff Laytonb647c352010-10-28 11:16:44 -04003127 spin_lock(&cifs_sb->tlink_tree_lock);
3128 while ((node = rb_first(root))) {
3129 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3130 cifs_get_tlink(tlink);
3131 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3132 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003133
Jeff Laytonb647c352010-10-28 11:16:44 -04003134 spin_unlock(&cifs_sb->tlink_tree_lock);
3135 cifs_put_tlink(tlink);
3136 spin_lock(&cifs_sb->tlink_tree_lock);
3137 }
3138 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003139
Steve French2fe87f02006-09-21 07:02:52 +00003140 tmp = cifs_sb->prepath;
3141 cifs_sb->prepathlen = 0;
3142 cifs_sb->prepath = NULL;
3143 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144
Jeff Layton9d002df2010-10-06 19:51:11 -04003145 return 0;
Steve French50c2f752007-07-13 00:33:32 +00003146}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147
Jeff Layton198b5682010-04-24 07:57:48 -04003148int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149{
3150 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003151 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152
Jeff Layton198b5682010-04-24 07:57:48 -04003153 /* only send once per connect */
3154 if (server->maxBuf != 0)
3155 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156
Jeff Layton198b5682010-04-24 07:57:48 -04003157 rc = CIFSSMBNegotiate(xid, ses);
3158 if (rc == -EAGAIN) {
3159 /* retry only once on 1st time connection */
3160 rc = CIFSSMBNegotiate(xid, ses);
3161 if (rc == -EAGAIN)
3162 rc = -EHOSTDOWN;
3163 }
3164 if (rc == 0) {
3165 spin_lock(&GlobalMid_Lock);
3166 if (server->tcpStatus != CifsExiting)
3167 server->tcpStatus = CifsGood;
3168 else
3169 rc = -EHOSTDOWN;
3170 spin_unlock(&GlobalMid_Lock);
3171
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 }
Steve French26b994f2008-08-06 05:11:33 +00003173
Jeff Layton198b5682010-04-24 07:57:48 -04003174 return rc;
3175}
Steve French26b994f2008-08-06 05:11:33 +00003176
Jeff Layton198b5682010-04-24 07:57:48 -04003177
3178int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3179 struct nls_table *nls_info)
3180{
3181 int rc = 0;
3182 struct TCP_Server_Info *server = ses->server;
3183
3184 ses->flags = 0;
3185 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003186 if (linuxExtEnabled == 0)
Jeff Layton198b5682010-04-24 07:57:48 -04003187 ses->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00003188
Joe Perchesb6b38f72010-04-21 03:50:45 +00003189 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3190 server->secMode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003191
Jeff Layton198b5682010-04-24 07:57:48 -04003192 rc = CIFS_SessSetup(xid, ses, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00003193 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003194 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00003195 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003196 mutex_lock(&ses->server->srv_mutex);
3197 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003198 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003199 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003200 server->sequence_number = 0x2;
3201 server->session_estab = true;
3202 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003203 }
3204 mutex_unlock(&server->srv_mutex);
3205
Joe Perchesb6b38f72010-04-21 03:50:45 +00003206 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00003207 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003208 ses->status = CifsGood;
3209 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003210 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003211 }
3212
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003213 kfree(ses->auth_key.response);
3214 ses->auth_key.response = NULL;
3215 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003216 kfree(ses->ntlmssp);
3217 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003218
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219 return rc;
3220}
3221
Steve Frenchd2445552010-10-08 03:38:46 +00003222static struct cifsTconInfo *
Jeff Layton9d002df2010-10-06 19:51:11 -04003223cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3224{
3225 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3226 struct cifsSesInfo *ses;
3227 struct cifsTconInfo *tcon = NULL;
3228 struct smb_vol *vol_info;
3229 char username[MAX_USERNAME_SIZE + 1];
3230
3231 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3232 if (vol_info == NULL) {
3233 tcon = ERR_PTR(-ENOMEM);
3234 goto out;
3235 }
3236
3237 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3238 vol_info->username = username;
3239 vol_info->local_nls = cifs_sb->local_nls;
3240 vol_info->linux_uid = fsuid;
3241 vol_info->cred_uid = fsuid;
3242 vol_info->UNC = master_tcon->treeName;
3243 vol_info->retry = master_tcon->retry;
3244 vol_info->nocase = master_tcon->nocase;
3245 vol_info->local_lease = master_tcon->local_lease;
3246 vol_info->no_linux_ext = !master_tcon->unix_ext;
3247
3248 /* FIXME: allow for other secFlg settings */
3249 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3250
3251 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303252 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003253 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303254 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003255
3256 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3257 if (IS_ERR(ses)) {
3258 tcon = (struct cifsTconInfo *)ses;
3259 cifs_put_tcp_session(master_tcon->ses->server);
3260 goto out;
3261 }
3262
3263 tcon = cifs_get_tcon(ses, vol_info);
3264 if (IS_ERR(tcon)) {
3265 cifs_put_smb_ses(ses);
3266 goto out;
3267 }
3268
3269 if (ses->capabilities & CAP_UNIX)
3270 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3271out:
3272 kfree(vol_info);
3273
3274 return tcon;
3275}
3276
Jeff Layton413e6612010-10-28 13:33:38 -04003277static inline struct tcon_link *
Jeff Layton9d002df2010-10-06 19:51:11 -04003278cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3279{
Jeff Layton413e6612010-10-28 13:33:38 -04003280 return cifs_sb->master_tlink;
Jeff Layton9d002df2010-10-06 19:51:11 -04003281}
3282
3283struct cifsTconInfo *
3284cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3285{
3286 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3287}
3288
3289static int
3290cifs_sb_tcon_pending_wait(void *unused)
3291{
3292 schedule();
3293 return signal_pending(current) ? -ERESTARTSYS : 0;
3294}
3295
Jeff Laytonb647c352010-10-28 11:16:44 -04003296/* find and return a tlink with given uid */
3297static struct tcon_link *
3298tlink_rb_search(struct rb_root *root, uid_t uid)
3299{
3300 struct rb_node *node = root->rb_node;
3301 struct tcon_link *tlink;
3302
3303 while (node) {
3304 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3305
3306 if (tlink->tl_uid > uid)
3307 node = node->rb_left;
3308 else if (tlink->tl_uid < uid)
3309 node = node->rb_right;
3310 else
3311 return tlink;
3312 }
3313 return NULL;
3314}
3315
3316/* insert a tcon_link into the tree */
3317static void
3318tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3319{
3320 struct rb_node **new = &(root->rb_node), *parent = NULL;
3321 struct tcon_link *tlink;
3322
3323 while (*new) {
3324 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3325 parent = *new;
3326
3327 if (tlink->tl_uid > new_tlink->tl_uid)
3328 new = &((*new)->rb_left);
3329 else
3330 new = &((*new)->rb_right);
3331 }
3332
3333 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3334 rb_insert_color(&new_tlink->tl_rbnode, root);
3335}
3336
Jeff Layton9d002df2010-10-06 19:51:11 -04003337/*
3338 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3339 * current task.
3340 *
3341 * If the superblock doesn't refer to a multiuser mount, then just return
3342 * the master tcon for the mount.
3343 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05303344 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04003345 * exists, then check to see if it's pending construction. If it is then wait
3346 * for construction to complete. Once it's no longer pending, check to see if
3347 * it failed and either return an error or retry construction, depending on
3348 * the timeout.
3349 *
3350 * If one doesn't exist then insert a new tcon_link struct into the tree and
3351 * try to construct a new one.
3352 */
3353struct tcon_link *
3354cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3355{
3356 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04003357 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04003358 struct tcon_link *tlink, *newtlink;
3359
3360 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3361 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3362
3363 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003364 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003365 if (tlink)
3366 cifs_get_tlink(tlink);
3367 spin_unlock(&cifs_sb->tlink_tree_lock);
3368
3369 if (tlink == NULL) {
3370 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3371 if (newtlink == NULL)
3372 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04003373 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003374 newtlink->tl_tcon = ERR_PTR(-EACCES);
3375 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3376 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3377 cifs_get_tlink(newtlink);
3378
Jeff Layton9d002df2010-10-06 19:51:11 -04003379 spin_lock(&cifs_sb->tlink_tree_lock);
3380 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04003381 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003382 if (tlink) {
3383 cifs_get_tlink(tlink);
3384 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003385 kfree(newtlink);
3386 goto wait_for_construction;
3387 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003388 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003389 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3390 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003391 } else {
3392wait_for_construction:
3393 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3394 cifs_sb_tcon_pending_wait,
3395 TASK_INTERRUPTIBLE);
3396 if (ret) {
3397 cifs_put_tlink(tlink);
3398 return ERR_PTR(ret);
3399 }
3400
3401 /* if it's good, return it */
3402 if (!IS_ERR(tlink->tl_tcon))
3403 return tlink;
3404
3405 /* return error if we tried this already recently */
3406 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3407 cifs_put_tlink(tlink);
3408 return ERR_PTR(-EACCES);
3409 }
3410
3411 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3412 goto wait_for_construction;
3413 }
3414
3415 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3416 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3417 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3418
3419 if (IS_ERR(tlink->tl_tcon)) {
3420 cifs_put_tlink(tlink);
3421 return ERR_PTR(-EACCES);
3422 }
3423
3424 return tlink;
3425}
Jeff Layton2de970f2010-10-06 19:51:12 -04003426
3427/*
3428 * periodic workqueue job that scans tcon_tree for a superblock and closes
3429 * out tcons.
3430 */
3431static void
3432cifs_prune_tlinks(struct work_struct *work)
3433{
3434 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3435 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04003436 struct rb_root *root = &cifs_sb->tlink_tree;
3437 struct rb_node *node = rb_first(root);
3438 struct rb_node *tmp;
3439 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04003440
Jeff Laytonb647c352010-10-28 11:16:44 -04003441 /*
3442 * Because we drop the spinlock in the loop in order to put the tlink
3443 * it's not guarded against removal of links from the tree. The only
3444 * places that remove entries from the tree are this function and
3445 * umounts. Because this function is non-reentrant and is canceled
3446 * before umount can proceed, this is safe.
3447 */
3448 spin_lock(&cifs_sb->tlink_tree_lock);
3449 node = rb_first(root);
3450 while (node != NULL) {
3451 tmp = node;
3452 node = rb_next(tmp);
3453 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3454
3455 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3456 atomic_read(&tlink->tl_count) != 0 ||
3457 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3458 continue;
3459
3460 cifs_get_tlink(tlink);
3461 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3462 rb_erase(tmp, root);
3463
Jeff Layton2de970f2010-10-06 19:51:12 -04003464 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003465 cifs_put_tlink(tlink);
3466 spin_lock(&cifs_sb->tlink_tree_lock);
3467 }
3468 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04003469
3470 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3471 TLINK_IDLE_EXPIRE);
3472}