blob: 9f59887badd2255457a384feffee95a98a2fb9e7 [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 */
Jeff Layton1397f2e2011-01-07 11:30:28 -050067 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
68 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
Jeff Layton3e4b3e12010-07-19 18:00:17 -040069 uid_t cred_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 uid_t linux_uid;
71 gid_t linux_gid;
72 mode_t file_mode;
73 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000074 unsigned secFlg;
Steve French4b18f2a2008-04-29 00:06:05 +000075 bool retry:1;
76 bool intr:1;
77 bool setuids:1;
78 bool override_uid:1;
79 bool override_gid:1;
Jeff Laytond0a9c072008-05-12 22:23:49 +000080 bool dynperm:1;
Steve French4b18f2a2008-04-29 00:06:05 +000081 bool noperm:1;
82 bool no_psx_acl:1; /* set if posix acl support should be disabled */
83 bool cifs_acl:1;
84 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
85 bool server_ino:1; /* use inode numbers from server ie UniqueId */
86 bool direct_io:1;
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
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300118static int ip_connect(struct TCP_Server_Info *server);
119static int generic_ip_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();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300203
204 /* we should try only the port we connected to before */
205 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000206 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000207 cFYI(1, "reconnect error %d", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700208 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 } else {
210 atomic_inc(&tcpSesReconnectCount);
211 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000212 if (server->tcpStatus != CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 server->tcpStatus = CifsGood;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000214 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 /* atomic_set(&server->inFlight,0);*/
216 wake_up(&server->response_q);
217 }
218 }
219 return rc;
220}
221
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000222/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700223 return codes:
224 0 not a transact2, or all data present
225 >0 transact2 with that much data missing
226 -EINVAL = invalid transact2
227
228 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000229static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700230{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000231 struct smb_t2_rsp *pSMBt;
232 int total_data_size;
Steve Frenche4eb2952005-04-28 22:41:09 -0700233 int data_in_this_rsp;
234 int remaining;
235
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000236 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700237 return 0;
238
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000239 /* check for plausible wct, bcc and t2 data and parm sizes */
240 /* check for parm and data offset going beyond end of smb */
241 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000242 cFYI(1, "invalid transact2 word count");
Steve Frenche4eb2952005-04-28 22:41:09 -0700243 return -EINVAL;
244 }
245
246 pSMBt = (struct smb_t2_rsp *)pSMB;
247
248 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
249 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
250
251 remaining = total_data_size - data_in_this_rsp;
252
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000253 if (remaining == 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700254 return 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000255 else if (remaining < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000256 cFYI(1, "total data %d smaller than data in frame %d",
257 total_data_size, data_in_this_rsp);
Steve Frenche4eb2952005-04-28 22:41:09 -0700258 return -EINVAL;
259 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000260 cFYI(1, "missing %d bytes from transact2, check next response",
261 remaining);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000262 if (total_data_size > maxBufSize) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000263 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
264 total_data_size, maxBufSize);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000265 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700266 }
267 return remaining;
268 }
269}
270
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000271static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700272{
273 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
274 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
275 int total_data_size;
276 int total_in_buf;
277 int remaining;
278 int total_in_buf2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000279 char *data_area_of_target;
280 char *data_area_of_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700281 __u16 byte_count;
282
283 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
284
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000285 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000286 cFYI(1, "total data size of primary and secondary t2 differ");
Steve Frenche4eb2952005-04-28 22:41:09 -0700287 }
288
289 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
290
291 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000292
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000293 if (remaining < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700294 return -EINVAL;
295
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000296 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700297 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000298
Steve Frenche4eb2952005-04-28 22:41:09 -0700299 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000300 if (remaining < total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000301 cFYI(1, "transact2 2nd response contains too much data");
Steve Frenche4eb2952005-04-28 22:41:09 -0700302 }
303
304 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000305 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Steve Frenche4eb2952005-04-28 22:41:09 -0700306 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
307 /* validate target area */
308
309 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000310 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700311
312 data_area_of_target += total_in_buf;
313
314 /* copy second buffer into end of first buffer */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000315 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
Steve Frenche4eb2952005-04-28 22:41:09 -0700316 total_in_buf += total_in_buf2;
317 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
318 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
319 byte_count += total_in_buf2;
320 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
321
Steve French70ca7342005-09-22 16:32:06 -0700322 byte_count = pTargetSMB->smb_buf_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700323 byte_count += total_in_buf2;
324
325 /* BB also add check that we are not beyond maximum buffer size */
Steve French50c2f752007-07-13 00:33:32 +0000326
Steve French70ca7342005-09-22 16:32:06 -0700327 pTargetSMB->smb_buf_length = byte_count;
Steve Frenche4eb2952005-04-28 22:41:09 -0700328
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000329 if (remaining == total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000330 cFYI(1, "found the last secondary response");
Steve Frenche4eb2952005-04-28 22:41:09 -0700331 return 0; /* we are done */
332 } else /* more responses to go */
333 return 1;
334
335}
336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337static int
338cifs_demultiplex_thread(struct TCP_Server_Info *server)
339{
340 int length;
341 unsigned int pdu_length, total_read;
342 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700343 struct smb_hdr *bigbuf = NULL;
344 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct msghdr smb_msg;
346 struct kvec iov;
347 struct socket *csocket = server->ssocket;
348 struct list_head *tmp;
349 struct cifsSesInfo *ses;
350 struct task_struct *task_to_wake = NULL;
351 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700352 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000353 bool isLargeBuf = false;
354 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700355 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000358 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400359
360 length = atomic_inc_return(&tcpSesAllocCount);
361 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000362 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
363 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700365 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000366 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700367 if (try_to_freeze())
368 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700369 if (bigbuf == NULL) {
370 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000371 if (!bigbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000372 cERROR(1, "No memory for large SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700373 msleep(3000);
374 /* retry will check if exiting */
375 continue;
376 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000377 } else if (isLargeBuf) {
378 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000379 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700381
382 if (smallbuf == NULL) {
383 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000384 if (!smallbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000385 cERROR(1, "No memory for SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700386 msleep(1000);
387 /* retry will check if exiting */
388 continue;
389 }
390 /* beginning of smb buffer is cleared in our buf_get */
391 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000392 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700393
Steve French4b18f2a2008-04-29 00:06:05 +0000394 isLargeBuf = false;
395 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700396 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 iov.iov_base = smb_buffer;
398 iov.iov_len = 4;
399 smb_msg.msg_control = NULL;
400 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000401 pdu_length = 4; /* enough to get RFC1001 header */
402incomplete_rcv:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 length =
404 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000405 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Jeff Layton469ee612008-10-16 18:46:39 +0000407 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 break;
409 } else if (server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000410 cFYI(1, "Reconnect after server stopped responding");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 cifs_reconnect(server);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000412 cFYI(1, "call to reconnect done");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 csocket = server->ssocket;
414 continue;
Jeff Layton522bbe62010-09-03 12:00:49 -0400415 } else if (length == -ERESTARTSYS ||
416 length == -EAGAIN ||
417 length == -EINTR) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700418 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 allowing socket to clear and app threads to set
420 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000421 if (pdu_length < 4) {
422 iov.iov_base = (4 - pdu_length) +
423 (char *)smb_buffer;
424 iov.iov_len = pdu_length;
425 smb_msg.msg_control = NULL;
426 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000427 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000428 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000429 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000431 cFYI(1, "Reconnect after unexpected peek error %d",
432 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 cifs_reconnect(server);
434 csocket = server->ssocket;
435 wake_up(&server->response_q);
436 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000437 } else if (length < pdu_length) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000438 cFYI(1, "requested %d bytes but only got %d bytes",
439 pdu_length, length);
Steve Frenchf01d5e12007-08-30 21:13:31 +0000440 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000441 msleep(1);
442 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 }
Steve French67010fb2005-04-28 22:41:09 -0700444
Steve French70ca7342005-09-22 16:32:06 -0700445 /* The right amount was read from socket - 4 bytes */
446 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700447
Steve French70ca7342005-09-22 16:32:06 -0700448 /* the first byte big endian of the length field,
449 is actually not part of the length but the type
450 with the most common, zero, as regular data */
451 temp = *((char *) smb_buffer);
452
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000453 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700454 but we convert it here so it is always manipulated
455 as host byte order */
Harvey Harrison5ca33c62008-07-23 17:45:58 -0700456 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
Steve French70ca7342005-09-22 16:32:06 -0700457 smb_buffer->smb_buf_length = pdu_length;
Steve French46810cb2005-04-28 22:41:09 -0700458
Joe Perchesb6b38f72010-04-21 03:50:45 +0000459 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
Steve French70ca7342005-09-22 16:32:06 -0700460
461 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000462 continue;
Steve French70ca7342005-09-22 16:32:06 -0700463 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000464 cFYI(1, "Good RFC 1002 session rsp");
Steve Frenche4eb2952005-04-28 22:41:09 -0700465 continue;
Steve French70ca7342005-09-22 16:32:06 -0700466 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000467 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700468 an error on SMB negprot response */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000469 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
470 pdu_length);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400471 /* give server a second to clean up */
472 msleep(1000);
473 /* always try 445 first on reconnect since we get NACK
474 * on some if we ever connected to port 139 (the NACK
475 * is since we do not begin with RFC1001 session
476 * initialize frame)
477 */
Jeff Layton32670392010-09-03 12:00:50 -0400478 cifs_set_port((struct sockaddr *)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300479 &server->dstaddr, CIFS_PORT);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400480 cifs_reconnect(server);
481 csocket = server->ssocket;
482 wake_up(&server->response_q);
483 continue;
Steve French70ca7342005-09-22 16:32:06 -0700484 } else if (temp != (char) 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000485 cERROR(1, "Unknown RFC 1002 frame");
Steve French70ca7342005-09-22 16:32:06 -0700486 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
487 length);
Steve French46810cb2005-04-28 22:41:09 -0700488 cifs_reconnect(server);
489 csocket = server->ssocket;
490 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700491 }
492
493 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000494 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000495 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000496 cERROR(1, "Invalid size SMB length %d pdu_length %d",
497 length, pdu_length+4);
Steve Frenche4eb2952005-04-28 22:41:09 -0700498 cifs_reconnect(server);
499 csocket = server->ssocket;
500 wake_up(&server->response_q);
501 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000502 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700503
504 /* else length ok */
505 reconnect = 0;
506
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000507 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000508 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700509 memcpy(bigbuf, smallbuf, 4);
510 smb_buffer = bigbuf;
511 }
512 length = 0;
513 iov.iov_base = 4 + (char *)smb_buffer;
514 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000515 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700516 total_read += length) {
517 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
518 pdu_length - total_read, 0);
Jeff Layton522bbe62010-09-03 12:00:49 -0400519 if (server->tcpStatus == CifsExiting) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700520 /* then will exit */
521 reconnect = 2;
522 break;
523 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700524 cifs_reconnect(server);
525 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000526 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700527 /* Now we will reread sock */
528 reconnect = 1;
529 break;
Jeff Layton522bbe62010-09-03 12:00:49 -0400530 } else if (length == -ERESTARTSYS ||
531 length == -EAGAIN ||
532 length == -EINTR) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700533 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000534 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700535 threads to set tcpStatus
536 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000537 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700538 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700539 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000540 cERROR(1, "Received no data, expecting %d",
541 pdu_length - total_read);
Steve Frenche4eb2952005-04-28 22:41:09 -0700542 cifs_reconnect(server);
543 csocket = server->ssocket;
544 reconnect = 1;
545 break;
Steve French46810cb2005-04-28 22:41:09 -0700546 }
547 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000548 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700549 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000550 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700551 continue;
552
553 length += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000554
Steve Frenche4eb2952005-04-28 22:41:09 -0700555
556 dump_smb(smb_buffer, length);
Steve French184ed212006-02-24 06:15:11 +0000557 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
Steve Frenchb387eae2005-10-10 14:21:15 -0700558 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
Steve Frenche4eb2952005-04-28 22:41:09 -0700559 continue;
560 }
561
562
563 task_to_wake = NULL;
564 spin_lock(&GlobalMid_Lock);
565 list_for_each(tmp, &server->pending_mid_q) {
566 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
567
Steve French50c2f752007-07-13 00:33:32 +0000568 if ((mid_entry->mid == smb_buffer->Mid) &&
Steve Frenche4eb2952005-04-28 22:41:09 -0700569 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
570 (mid_entry->command == smb_buffer->Command)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000571 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700572 /* We have a multipart transact2 resp */
Steve French4b18f2a2008-04-29 00:06:05 +0000573 isMultiRsp = true;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000574 if (mid_entry->resp_buf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700575 /* merge response - fix up 1st*/
Steve French50c2f752007-07-13 00:33:32 +0000576 if (coalesce_t2(smb_buffer,
Steve Frenche4eb2952005-04-28 22:41:09 -0700577 mid_entry->resp_buf)) {
Steve French4b18f2a2008-04-29 00:06:05 +0000578 mid_entry->multiRsp =
579 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700580 break;
581 } else {
582 /* all parts received */
Steve French4b18f2a2008-04-29 00:06:05 +0000583 mid_entry->multiEnd =
584 true;
Steve French50c2f752007-07-13 00:33:32 +0000585 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700586 }
587 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000588 if (!isLargeBuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000589 cERROR(1, "1st trans2 resp needs bigbuf");
Steve Frenche4eb2952005-04-28 22:41:09 -0700590 /* BB maybe we can fix this up, switch
Steve French50c2f752007-07-13 00:33:32 +0000591 to already allocated large buffer? */
Steve Frenche4eb2952005-04-28 22:41:09 -0700592 } else {
Steve Frenchcd634992005-04-28 22:41:10 -0700593 /* Have first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700594 mid_entry->resp_buf =
595 smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000596 mid_entry->largeBuf =
597 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700598 bigbuf = NULL;
599 }
600 }
601 break;
Steve French50c2f752007-07-13 00:33:32 +0000602 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700603 mid_entry->resp_buf = smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000604 mid_entry->largeBuf = isLargeBuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700605multi_t2_fnd:
606 task_to_wake = mid_entry->tsk;
607 mid_entry->midState = MID_RESPONSE_RECEIVED;
Steve French1047abc2005-10-11 19:58:06 -0700608#ifdef CONFIG_CIFS_STATS2
609 mid_entry->when_received = jiffies;
610#endif
Steve French3a5ff612006-07-14 22:37:11 +0000611 /* so we do not time out requests to server
612 which is still responding (since server could
613 be busy but not dead) */
614 server->lstrp = jiffies;
Steve Frenche4eb2952005-04-28 22:41:09 -0700615 break;
616 }
617 }
618 spin_unlock(&GlobalMid_Lock);
619 if (task_to_wake) {
Steve Frenchcd634992005-04-28 22:41:10 -0700620 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000621 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700622 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000623 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700624 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000625 else
Steve Frenchcd634992005-04-28 22:41:10 -0700626 smallbuf = NULL;
627 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700628 wake_up_process(task_to_wake);
Steve French4b18f2a2008-04-29 00:06:05 +0000629 } else if (!is_valid_oplock_break(smb_buffer, server) &&
630 !isMultiRsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000631 cERROR(1, "No task to wake, unknown frame received! "
632 "NumMids %d", midCount.counter);
Steve French50c2f752007-07-13 00:33:32 +0000633 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700634 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000635#ifdef CONFIG_CIFS_DEBUG2
636 cifs_dump_detail(smb_buffer);
637 cifs_dump_mids(server);
638#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000639
Steve Frenche4eb2952005-04-28 22:41:09 -0700640 }
641 } /* end while !EXITING */
642
Jeff Laytone7ddee92008-11-14 13:44:38 -0500643 /* take it off the list, if it's not already */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530644 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500645 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530646 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 spin_lock(&GlobalMid_Lock);
649 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000650 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000651 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000652
Steve French31ca3bc2005-04-28 22:41:11 -0700653 /* check if we have blocked requests that need to free */
654 /* Note that cifs_max_pending is normally 50, but
655 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000656 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000657 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700658 atomic_set(&server->inFlight, cifs_max_pending - 1);
659 /* We do not want to set the max_pending too low or we
660 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000662 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700664 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 to the same server - they now will see the session is in exit state
666 and get out of SendReceive. */
667 wake_up_all(&server->request_q);
668 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700669 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000670
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000671 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 sock_release(csocket);
673 server->ssocket = NULL;
674 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700675 /* buffer usuallly freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000676 cifs_buf_release(bigbuf);
677 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700678 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Jeff Layton14fbf502008-11-14 13:53:46 -0500680 /*
681 * BB: we shouldn't have to do any of this. It shouldn't be
682 * possible to exit from the thread with active SMB sessions
683 */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530684 spin_lock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 if (list_empty(&server->pending_mid_q)) {
Steve French09d1db52005-04-28 22:41:08 -0700686 /* loop through server session structures attached to this and
687 mark them dead */
Jeff Layton14fbf502008-11-14 13:53:46 -0500688 list_for_each(tmp, &server->smb_ses_list) {
689 ses = list_entry(tmp, struct cifsSesInfo,
690 smb_ses_list);
691 ses->status = CifsExiting;
692 ses->server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530694 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 } else {
Steve French31ca3bc2005-04-28 22:41:11 -0700696 /* although we can not zero the server struct pointer yet,
697 since there are active requests which may depnd on them,
698 mark the corresponding SMB sessions as exiting too */
Jeff Layton14fbf502008-11-14 13:53:46 -0500699 list_for_each(tmp, &server->smb_ses_list) {
Steve French31ca3bc2005-04-28 22:41:11 -0700700 ses = list_entry(tmp, struct cifsSesInfo,
Jeff Layton14fbf502008-11-14 13:53:46 -0500701 smb_ses_list);
702 ses->status = CifsExiting;
Steve French31ca3bc2005-04-28 22:41:11 -0700703 }
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 spin_lock(&GlobalMid_Lock);
706 list_for_each(tmp, &server->pending_mid_q) {
707 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
708 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000709 cFYI(1, "Clearing Mid 0x%x - waking up ",
710 mid_entry->mid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 task_to_wake = mid_entry->tsk;
Steve French26f57362007-08-30 22:09:15 +0000712 if (task_to_wake)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 wake_up_process(task_to_wake);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 }
715 }
716 spin_unlock(&GlobalMid_Lock);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530717 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700719 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 }
721
Steve Frenchf1914012005-08-18 09:37:34 -0700722 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000723 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700725 /* due to delays on oplock break requests, we need
726 to wait at least 45 seconds before giving up
727 on a request getting a response and going ahead
728 and killing cifsd */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000729 cFYI(1, "Wait for exit from demultiplex thread");
Steve French31ca3bc2005-04-28 22:41:11 -0700730 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 /* if threads still have not exited they are probably never
732 coming home not much else we can do but free the memory */
733 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
Steve French31ca3bc2005-04-28 22:41:11 -0700735 /* last chance to mark ses pointers invalid
736 if there are any pointing to this (e.g
Steve French50c2f752007-07-13 00:33:32 +0000737 if a crazy root user tried to kill cifsd
Steve French31ca3bc2005-04-28 22:41:11 -0700738 kernel thread explicitly this might happen) */
Jeff Layton14fbf502008-11-14 13:53:46 -0500739 /* BB: This shouldn't be necessary, see above */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530740 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500741 list_for_each(tmp, &server->smb_ses_list) {
742 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
743 ses->server = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700744 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530745 spin_unlock(&cifs_tcp_ses_lock);
Steve French31ca3bc2005-04-28 22:41:11 -0700746
Jeff Laytonc359cf32007-11-16 22:22:06 +0000747 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400748 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700749 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400750
751 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000752 if (length > 0)
753 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
754 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000755
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400756 /* if server->tsk was NULL then wait for a signal before exiting */
757 if (!task_to_wake) {
758 set_current_state(TASK_INTERRUPTIBLE);
759 while (!signal_pending(current)) {
760 schedule();
761 set_current_state(TASK_INTERRUPTIBLE);
762 }
763 set_current_state(TASK_RUNNING);
764 }
765
Jeff Layton0468a2c2008-12-01 07:09:35 -0500766 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767}
768
Jeff Laytonc359cf32007-11-16 22:22:06 +0000769/* extract the host portion of the UNC string */
770static char *
771extract_hostname(const char *unc)
772{
773 const char *src;
774 char *dst, *delim;
775 unsigned int len;
776
777 /* skip double chars at beginning of string */
778 /* BB: check validity of these bytes? */
779 src = unc + 2;
780
781 /* delimiter between hostname and sharename is always '\\' now */
782 delim = strchr(src, '\\');
783 if (!delim)
784 return ERR_PTR(-EINVAL);
785
786 len = delim - src;
787 dst = kmalloc((len + 1), GFP_KERNEL);
788 if (dst == NULL)
789 return ERR_PTR(-ENOMEM);
790
791 memcpy(dst, src, len);
792 dst[len] = '\0';
793
794 return dst;
795}
796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797static int
Steve French50c2f752007-07-13 00:33:32 +0000798cifs_parse_mount_options(char *options, const char *devname,
799 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800{
801 char *value;
802 char *data;
803 unsigned int temp_len, i, j;
804 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -0400805 short int override_uid = -1;
806 short int override_gid = -1;
807 bool uid_specified = false;
808 bool gid_specified = false;
Jeff Layton88463992010-11-22 15:31:03 -0500809 char *nodename = utsname()->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
811 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000812 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Jeff Layton88463992010-11-22 15:31:03 -0500814 /*
815 * does not have to be perfect mapping since field is
816 * informational, only used for servers that do not support
817 * port 445 and it can be overridden at mount time
818 */
Jeff Layton1397f2e2011-01-07 11:30:28 -0500819 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
820 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -0500821 vol->source_rfc1001_name[i] = toupper(nodename[i]);
822
Jeff Layton1397f2e2011-01-07 11:30:28 -0500823 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700824 /* null target name indicates to use *SMBSERVR default called name
825 if we end up sending RFC1001 session initialize */
826 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400827 vol->cred_uid = current_uid();
828 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +1100829 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400830
831 /* default to only allowing write access to owner of the mount */
832 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -0700835 /* default is always to request posix paths. */
836 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400837 /* default to using server inode numbers where available */
838 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700839
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530840 vol->actimeo = CIFS_DEF_ACTIMEO;
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 if (!options)
843 return 1;
844
Steve French50c2f752007-07-13 00:33:32 +0000845 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000846 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 separator[0] = options[4];
848 options += 5;
849 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000850 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 }
852 }
Steve French50c2f752007-07-13 00:33:32 +0000853
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 while ((data = strsep(&options, separator)) != NULL) {
855 if (!*data)
856 continue;
857 if ((value = strchr(data, '=')) != NULL)
858 *value++ = '\0';
859
Steve French50c2f752007-07-13 00:33:32 +0000860 /* Have to parse this before we parse for "user" */
861 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000863 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 vol->no_xattr = 1;
865 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000866 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 printk(KERN_WARNING
868 "CIFS: invalid or missing username\n");
869 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000870 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000871 /* null user, ie anonymous, authentication */
872 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
874 if (strnlen(value, 200) < 200) {
875 vol->username = value;
876 } else {
877 printk(KERN_WARNING "CIFS: username too long\n");
878 return 1;
879 }
880 } else if (strnicmp(data, "pass", 4) == 0) {
881 if (!value) {
882 vol->password = NULL;
883 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000884 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 /* check if string begins with double comma
886 since that would mean the password really
887 does start with a comma, and would not
888 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000889 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 vol->password = NULL;
891 continue;
892 }
893 }
894 temp_len = strlen(value);
895 /* removed password length check, NTLM passwords
896 can be arbitrarily long */
897
Steve French50c2f752007-07-13 00:33:32 +0000898 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 prematurely null terminated. Commas in password are
900 specified across the cifs mount interface by a double
901 comma ie ,, and a comma used as in other cases ie ','
902 as a parameter delimiter/separator is single and due
903 to the strsep above is temporarily zeroed. */
904
905 /* NB: password legally can have multiple commas and
906 the only illegal character in a password is null */
907
Steve French50c2f752007-07-13 00:33:32 +0000908 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700909 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 /* reinsert comma */
911 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000912 temp_len += 2; /* move after second comma */
913 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000915 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700916 separator[0]) {
917 /* skip second comma */
918 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000919 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 /* single comma indicating start
921 of next parm */
922 break;
923 }
924 }
925 temp_len++;
926 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000927 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 options = NULL;
929 } else {
930 value[temp_len] = 0;
931 /* point option to start of next parm */
932 options = value + temp_len + 1;
933 }
Steve French50c2f752007-07-13 00:33:32 +0000934 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 double commas to singles. Note that this ends up
936 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700937 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000938 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000939 printk(KERN_WARNING "CIFS: no memory "
940 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700941 return 1;
942 }
Steve French50c2f752007-07-13 00:33:32 +0000943 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000945 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700946 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 /* skip second comma */
948 i++;
949 }
950 }
951 vol->password[j] = 0;
952 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700953 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000954 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000955 printk(KERN_WARNING "CIFS: no memory "
956 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700957 return 1;
958 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 strcpy(vol->password, value);
960 }
Jeff Layton58f7f682009-06-10 09:57:55 -0400961 } else if (!strnicmp(data, "ip", 2) ||
962 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 if (!value || !*value) {
964 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -0400965 } else if (strnlen(value, INET6_ADDRSTRLEN) <
966 INET6_ADDRSTRLEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 vol->UNCip = value;
968 } else {
Steve French50c2f752007-07-13 00:33:32 +0000969 printk(KERN_WARNING "CIFS: ip address "
970 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 return 1;
972 }
Steve French50c2f752007-07-13 00:33:32 +0000973 } else if (strnicmp(data, "sec", 3) == 0) {
974 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000975 cERROR(1, "no security value specified");
Steve French50c2f752007-07-13 00:33:32 +0000976 continue;
977 } else if (strnicmp(value, "krb5i", 5) == 0) {
978 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000979 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800980 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000981 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
982 CIFSSEC_MAY_KRB5; */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000983 cERROR(1, "Krb5 cifs privacy not supported");
Steve Frenchbf820672005-12-01 22:32:42 -0800984 return 1;
985 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000986 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +0000987 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
989 CIFSSEC_MUST_SIGN;
990 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
991 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
Steve Frenchbf820672005-12-01 22:32:42 -0800992 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000993 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000994 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800995 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000996 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -0800997 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000998 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +0000999 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001000 } else if (strnicmp(value, "ntlm", 4) == 0) {
1001 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001002 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001003 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001004 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001005 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001006#ifdef CONFIG_CIFS_WEAK_PW_HASH
1007 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001008 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001009#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001010 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001011 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001012 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001013 cERROR(1, "bad security option: %s", value);
Steve French50c2f752007-07-13 00:33:32 +00001014 return 1;
1015 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 } else if ((strnicmp(data, "unc", 3) == 0)
1017 || (strnicmp(data, "target", 6) == 0)
1018 || (strnicmp(data, "path", 4) == 0)) {
1019 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001020 printk(KERN_WARNING "CIFS: invalid path to "
1021 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return 1; /* needs_arg; */
1023 }
1024 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001025 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001026 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001028 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 if (strncmp(vol->UNC, "//", 2) == 0) {
1030 vol->UNC[0] = '\\';
1031 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001032 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001034 "CIFS: UNC Path does not begin "
1035 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 return 1;
1037 }
1038 } else {
1039 printk(KERN_WARNING "CIFS: UNC name too long\n");
1040 return 1;
1041 }
1042 } else if ((strnicmp(data, "domain", 3) == 0)
1043 || (strnicmp(data, "workgroup", 5) == 0)) {
1044 if (!value || !*value) {
1045 printk(KERN_WARNING "CIFS: invalid domain name\n");
1046 return 1; /* needs_arg; */
1047 }
1048 /* BB are there cases in which a comma can be valid in
1049 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001050 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 vol->domainname = value;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001052 cFYI(1, "Domain name set");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 } else {
Steve French50c2f752007-07-13 00:33:32 +00001054 printk(KERN_WARNING "CIFS: domain name too "
1055 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 return 1;
1057 }
Ben Greear3eb9a882010-09-01 17:06:02 -07001058 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1059 vol->srcaddr.ss_family = AF_UNSPEC;
1060
1061 if (!value || !*value) {
1062 printk(KERN_WARNING "CIFS: srcaddr value"
1063 " not specified.\n");
1064 return 1; /* needs_arg; */
1065 }
1066 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1067 value, strlen(value));
Dan Carpenterb235f372010-10-25 07:02:56 +02001068 if (i == 0) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001069 printk(KERN_WARNING "CIFS: Could not parse"
1070 " srcaddr: %s\n",
1071 value);
1072 return 1;
1073 }
Steve French50c2f752007-07-13 00:33:32 +00001074 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1075 if (!value || !*value) {
1076 printk(KERN_WARNING
1077 "CIFS: invalid path prefix\n");
1078 return 1; /* needs_argument */
1079 }
1080 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001081 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001082 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001083 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1084 if (vol->prepath == NULL)
1085 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001086 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001087 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001088 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001089 } else
Steve French50c2f752007-07-13 00:33:32 +00001090 strcpy(vol->prepath, value);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001091 cFYI(1, "prefix path %s", vol->prepath);
Steve French50c2f752007-07-13 00:33:32 +00001092 } else {
1093 printk(KERN_WARNING "CIFS: prefix too long\n");
1094 return 1;
1095 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 } else if (strnicmp(data, "iocharset", 9) == 0) {
1097 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001098 printk(KERN_WARNING "CIFS: invalid iocharset "
1099 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 return 1; /* needs_arg; */
1101 }
1102 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001103 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001105 /* if iocharset not set then load_nls_default
1106 is used by caller */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001107 cFYI(1, "iocharset set to %s", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 } else {
Steve French63135e02007-07-17 17:34:02 +00001109 printk(KERN_WARNING "CIFS: iocharset name "
1110 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 return 1;
1112 }
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001113 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1114 vol->linux_uid = simple_strtoul(value, &value, 0);
1115 uid_specified = true;
Jeff Laytonbd763312011-01-11 10:33:24 -05001116 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1117 vol->cred_uid = simple_strtoul(value, &value, 0);
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001118 } else if (!strnicmp(data, "forceuid", 8)) {
1119 override_uid = 1;
1120 } else if (!strnicmp(data, "noforceuid", 10)) {
1121 override_uid = 0;
1122 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1123 vol->linux_gid = simple_strtoul(value, &value, 0);
1124 gid_specified = true;
1125 } else if (!strnicmp(data, "forcegid", 8)) {
1126 override_gid = 1;
1127 } else if (!strnicmp(data, "noforcegid", 10)) {
1128 override_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 } else if (strnicmp(data, "file_mode", 4) == 0) {
1130 if (value && *value) {
1131 vol->file_mode =
1132 simple_strtoul(value, &value, 0);
1133 }
1134 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1135 if (value && *value) {
1136 vol->dir_mode =
1137 simple_strtoul(value, &value, 0);
1138 }
1139 } else if (strnicmp(data, "dirmode", 4) == 0) {
1140 if (value && *value) {
1141 vol->dir_mode =
1142 simple_strtoul(value, &value, 0);
1143 }
1144 } else if (strnicmp(data, "port", 4) == 0) {
1145 if (value && *value) {
1146 vol->port =
1147 simple_strtoul(value, &value, 0);
1148 }
1149 } else if (strnicmp(data, "rsize", 5) == 0) {
1150 if (value && *value) {
1151 vol->rsize =
1152 simple_strtoul(value, &value, 0);
1153 }
1154 } else if (strnicmp(data, "wsize", 5) == 0) {
1155 if (value && *value) {
1156 vol->wsize =
1157 simple_strtoul(value, &value, 0);
1158 }
1159 } else if (strnicmp(data, "sockopt", 5) == 0) {
Steve French6a5fa2362010-01-01 01:28:43 +00001160 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001161 cERROR(1, "no socket option specified");
Steve French6a5fa2362010-01-01 01:28:43 +00001162 continue;
1163 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1164 vol->sockopt_tcp_nodelay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 }
1166 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1167 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001168 cFYI(1, "invalid (empty) netbiosname");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 } else {
Jeff Layton1397f2e2011-01-07 11:30:28 -05001170 memset(vol->source_rfc1001_name, 0x20,
1171 RFC1001_NAME_LEN);
1172 /*
1173 * FIXME: are there cases in which a comma can
1174 * be valid in workstation netbios name (and
1175 * need special handling)?
1176 */
1177 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1178 /* don't ucase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001179 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 break;
Jeff Layton1397f2e2011-01-07 11:30:28 -05001181 vol->source_rfc1001_name[i] = value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 }
1183 /* The string has 16th byte zero still from
1184 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001185 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001186 printk(KERN_WARNING "CIFS: netbiosname"
1187 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001188 }
1189 } else if (strnicmp(data, "servern", 7) == 0) {
1190 /* servernetbiosname specified override *SMBSERVER */
1191 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001192 cFYI(1, "empty server netbiosname specified");
Steve Frencha10faeb22005-08-22 21:38:31 -07001193 } else {
1194 /* last byte, type, is 0x20 for servr type */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001195 memset(vol->target_rfc1001_name, 0x20,
1196 RFC1001_NAME_LEN_WITH_NULL);
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 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001213 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001214 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 } else if (strnicmp(data, "locallease", 6) == 0) {
1345 vol->local_lease = 1;
Steve French50c2f752007-07-13 00:33:32 +00001346 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001347 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001348 } else if (strnicmp(data, "seal", 4) == 0) {
1349 /* we do not do the following in secFlags because seal
1350 is a per tree connection (mount) not a per socket
1351 or per-smb connection option in the protocol */
1352 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1353 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001354 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001356 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 vol->direct_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001359 printk(KERN_WARNING "CIFS: Mount option noac not "
1360 "supported. Instead set "
1361 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301362 } else if (strnicmp(data, "fsc", 3) == 0) {
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301363#ifndef CONFIG_CIFS_FSCACHE
1364 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1365 "kernel config option set");
1366 return 1;
1367#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301368 vol->fsc = true;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001369 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1370 vol->mfsymlinks = true;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001371 } else if (strnicmp(data, "multiuser", 8) == 0) {
1372 vol->multiuser = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 } else
Steve French50c2f752007-07-13 00:33:32 +00001374 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1375 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 }
1377 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001378 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001379 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1380 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 return 1;
1382 }
1383 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001384 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001385 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001387 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 if (strncmp(vol->UNC, "//", 2) == 0) {
1389 vol->UNC[0] = '\\';
1390 vol->UNC[1] = '\\';
1391 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001392 printk(KERN_WARNING "CIFS: UNC Path does not "
1393 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 return 1;
1395 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001396 value = strpbrk(vol->UNC+2, "/\\");
1397 if (value)
1398 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 } else {
1400 printk(KERN_WARNING "CIFS: UNC name too long\n");
1401 return 1;
1402 }
1403 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001404
1405 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1406 cERROR(1, "Multiuser mounts currently require krb5 "
1407 "authentication!");
1408 return 1;
1409 }
1410
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001411 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 vol->UNCip = &vol->UNC[2];
1413
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001414 if (uid_specified)
1415 vol->override_uid = override_uid;
1416 else if (override_uid == 1)
1417 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1418 "specified with no uid= option.\n");
1419
1420 if (gid_specified)
1421 vol->override_gid = override_gid;
1422 else if (override_gid == 1)
1423 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1424 "specified with no gid= option.\n");
1425
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 return 0;
1427}
1428
Ben Greear3eb9a882010-09-01 17:06:02 -07001429/** Returns true if srcaddr isn't specified and rhs isn't
1430 * specified, or if srcaddr is specified and
1431 * matches the IP address of the rhs argument.
1432 */
Jeff Layton45151482010-07-06 20:43:02 -04001433static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001434srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1435{
1436 switch (srcaddr->sa_family) {
1437 case AF_UNSPEC:
1438 return (rhs->sa_family == AF_UNSPEC);
1439 case AF_INET: {
1440 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1441 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1442 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1443 }
1444 case AF_INET6: {
1445 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1446 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1447 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1448 }
1449 default:
1450 WARN_ON(1);
1451 return false; /* don't expect to be here */
1452 }
1453}
1454
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001455/*
1456 * If no port is specified in addr structure, we try to match with 445 port
1457 * and if it fails - with 139 ports. It should be called only if address
1458 * families of server and addr are equal.
1459 */
1460static bool
1461match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1462{
1463 unsigned short int port, *sport;
1464
1465 switch (addr->sa_family) {
1466 case AF_INET:
1467 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1468 port = ((struct sockaddr_in *) addr)->sin_port;
1469 break;
1470 case AF_INET6:
1471 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1472 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1473 break;
1474 default:
1475 WARN_ON(1);
1476 return false;
1477 }
1478
1479 if (!port) {
1480 port = htons(CIFS_PORT);
1481 if (port == *sport)
1482 return true;
1483
1484 port = htons(RFC1001_PORT);
1485 }
1486
1487 return port == *sport;
1488}
Ben Greear3eb9a882010-09-01 17:06:02 -07001489
1490static bool
1491match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1492 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493{
Jeff Layton45151482010-07-06 20:43:02 -04001494 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001495 case AF_INET: {
1496 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1497 struct sockaddr_in *srv_addr4 =
1498 (struct sockaddr_in *)&server->dstaddr;
1499
1500 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001501 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001502 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001503 }
1504 case AF_INET6: {
1505 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1506 struct sockaddr_in6 *srv_addr6 =
1507 (struct sockaddr_in6 *)&server->dstaddr;
1508
Jeff Layton45151482010-07-06 20:43:02 -04001509 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001510 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001511 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001512 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001513 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001514 break;
1515 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001516 default:
1517 WARN_ON(1);
1518 return false; /* don't expect to be here */
1519 }
Jeff Layton45151482010-07-06 20:43:02 -04001520
Ben Greear3eb9a882010-09-01 17:06:02 -07001521 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1522 return false;
1523
Jeff Layton45151482010-07-06 20:43:02 -04001524 return true;
1525}
1526
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001527static bool
1528match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1529{
1530 unsigned int secFlags;
1531
1532 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1533 secFlags = vol->secFlg;
1534 else
1535 secFlags = global_secflags | vol->secFlg;
1536
1537 switch (server->secType) {
1538 case LANMAN:
1539 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1540 return false;
1541 break;
1542 case NTLMv2:
1543 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1544 return false;
1545 break;
1546 case NTLM:
1547 if (!(secFlags & CIFSSEC_MAY_NTLM))
1548 return false;
1549 break;
1550 case Kerberos:
1551 if (!(secFlags & CIFSSEC_MAY_KRB5))
1552 return false;
1553 break;
1554 case RawNTLMSSP:
1555 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1556 return false;
1557 break;
1558 default:
1559 /* shouldn't happen */
1560 return false;
1561 }
1562
1563 /* now check if signing mode is acceptible */
1564 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1565 (server->secMode & SECMODE_SIGN_REQUIRED))
1566 return false;
1567 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1568 (server->secMode &
1569 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1570 return false;
1571
1572 return true;
1573}
1574
Jeff Layton45151482010-07-06 20:43:02 -04001575static struct TCP_Server_Info *
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001576cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04001577{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001578 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301580 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04001581 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001582 if (!match_address(server, addr,
1583 (struct sockaddr *)&vol->srcaddr))
Jeff Layton45151482010-07-06 20:43:02 -04001584 continue;
Steve French50c2f752007-07-13 00:33:32 +00001585
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001586 if (!match_port(server, addr))
1587 continue;
1588
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001589 if (!match_security(server, vol))
1590 continue;
1591
Jeff Laytone7ddee92008-11-14 13:44:38 -05001592 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301593 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001594 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05001595 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301597 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 return NULL;
1599}
1600
Jeff Layton14fbf502008-11-14 13:53:46 -05001601static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001602cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001604 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301606 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001607 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301608 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001609 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001611
Jeff Laytone7ddee92008-11-14 13:44:38 -05001612 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301613 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001614
1615 spin_lock(&GlobalMid_Lock);
1616 server->tcpStatus = CifsExiting;
1617 spin_unlock(&GlobalMid_Lock);
1618
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001619 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301620 cifs_fscache_release_client_cookie(server);
1621
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05001622 kfree(server->session_key.response);
1623 server->session_key.response = NULL;
1624 server->session_key.len = 0;
1625
Jeff Laytone7ddee92008-11-14 13:44:38 -05001626 task = xchg(&server->tsk, NULL);
1627 if (task)
1628 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629}
1630
Jeff Layton63c038c2008-12-01 18:41:46 -05001631static struct TCP_Server_Info *
1632cifs_get_tcp_session(struct smb_vol *volume_info)
1633{
1634 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001635 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001636 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1637 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1638 int rc;
1639
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001640 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001641
Joe Perchesb6b38f72010-04-21 03:50:45 +00001642 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001643
Jeff Layton63c038c2008-12-01 18:41:46 -05001644 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton50d97162010-07-06 20:43:01 -04001645 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1646 volume_info->UNCip,
David Howells67b76262010-07-22 18:33:01 +01001647 strlen(volume_info->UNCip),
Jeff Layton50d97162010-07-06 20:43:01 -04001648 volume_info->port);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001649 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001650 /* we failed translating address */
1651 rc = -EINVAL;
1652 goto out_err;
1653 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001654 } else if (volume_info->UNCip) {
1655 /* BB using ip addr as tcp_ses name to connect to the
1656 DFS root below */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001657 cERROR(1, "Connecting to DFS root not implemented yet");
Jeff Layton63c038c2008-12-01 18:41:46 -05001658 rc = -EINVAL;
1659 goto out_err;
1660 } else /* which tcp_sess DFS root would we conect to */ {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001661 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1662 "unc=//192.168.1.100/public) specified");
Jeff Layton63c038c2008-12-01 18:41:46 -05001663 rc = -EINVAL;
1664 goto out_err;
1665 }
1666
1667 /* see if we already have a matching tcp_ses */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001668 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05001669 if (tcp_ses)
1670 return tcp_ses;
1671
1672 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1673 if (!tcp_ses) {
1674 rc = -ENOMEM;
1675 goto out_err;
1676 }
1677
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001678 rc = cifs_crypto_shash_allocate(tcp_ses);
1679 if (rc) {
1680 cERROR(1, "could not setup hash structures rc %d", rc);
1681 goto out_err;
1682 }
1683
Jeff Layton63c038c2008-12-01 18:41:46 -05001684 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1685 if (IS_ERR(tcp_ses->hostname)) {
1686 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001687 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001688 }
1689
1690 tcp_ses->noblocksnd = volume_info->noblocksnd;
1691 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00001692 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Jeff Layton63c038c2008-12-01 18:41:46 -05001693 atomic_set(&tcp_ses->inFlight, 0);
1694 init_waitqueue_head(&tcp_ses->response_q);
1695 init_waitqueue_head(&tcp_ses->request_q);
1696 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1697 mutex_init(&tcp_ses->srv_mutex);
1698 memcpy(tcp_ses->workstation_RFC1001_name,
1699 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1700 memcpy(tcp_ses->server_RFC1001_name,
1701 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05001702 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05001703 tcp_ses->sequence_number = 0;
1704 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1705 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1706
1707 /*
1708 * at this point we are the only ones with the pointer
1709 * to the struct since the kernel thread not created yet
1710 * no need to spinlock this init of tcpStatus or srv_count
1711 */
1712 tcp_ses->tcpStatus = CifsNew;
Ben Greear3eb9a882010-09-01 17:06:02 -07001713 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1714 sizeof(tcp_ses->srcaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05001715 ++tcp_ses->srv_count;
1716
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001717 if (addr.ss_family == AF_INET6) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001718 cFYI(1, "attempting ipv6 connect");
Jeff Layton63c038c2008-12-01 18:41:46 -05001719 /* BB should we allow ipv6 on port 139? */
1720 /* other OS never observed in Wild doing 139 with v6 */
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001721 memcpy(&tcp_ses->dstaddr, sin_server6,
1722 sizeof(struct sockaddr_in6));
1723 } else
1724 memcpy(&tcp_ses->dstaddr, sin_server,
1725 sizeof(struct sockaddr_in));
1726
1727 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001728 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001729 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001730 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001731 }
1732
1733 /*
1734 * since we're in a cifs function already, we know that
1735 * this will succeed. No need for try_module_get().
1736 */
1737 __module_get(THIS_MODULE);
1738 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1739 tcp_ses, "cifsd");
1740 if (IS_ERR(tcp_ses->tsk)) {
1741 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001742 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05001743 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001744 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001745 }
1746
1747 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301748 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001749 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301750 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001751
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301752 cifs_fscache_get_client_cookie(tcp_ses);
1753
Jeff Layton63c038c2008-12-01 18:41:46 -05001754 return tcp_ses;
1755
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001756out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001757 cifs_crypto_shash_release(tcp_ses);
1758
Jeff Layton63c038c2008-12-01 18:41:46 -05001759out_err:
1760 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00001761 if (!IS_ERR(tcp_ses->hostname))
1762 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05001763 if (tcp_ses->ssocket)
1764 sock_release(tcp_ses->ssocket);
1765 kfree(tcp_ses);
1766 }
1767 return ERR_PTR(rc);
1768}
1769
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770static struct cifsSesInfo *
Jeff Layton4ff67b72010-07-06 20:43:02 -04001771cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 struct cifsSesInfo *ses;
1774
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301775 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04001776 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1777 switch (server->secType) {
1778 case Kerberos:
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001779 if (vol->cred_uid != ses->cred_uid)
Jeff Layton4ff67b72010-07-06 20:43:02 -04001780 continue;
1781 break;
1782 default:
1783 /* anything else takes username/password */
1784 if (strncmp(ses->userName, vol->username,
1785 MAX_USERNAME_SIZE))
1786 continue;
1787 if (strlen(vol->username) != 0 &&
Jeff Layton24e6cf92010-08-23 11:38:04 -04001788 ses->password != NULL &&
Jeff Laytonfc87a402010-08-18 13:13:39 -04001789 strncmp(ses->password,
1790 vol->password ? vol->password : "",
Jeff Layton4ff67b72010-07-06 20:43:02 -04001791 MAX_PASSWORD_SIZE))
1792 continue;
1793 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001794 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301795 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001796 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301798 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 return NULL;
1800}
1801
Jeff Layton14fbf502008-11-14 13:53:46 -05001802static void
1803cifs_put_smb_ses(struct cifsSesInfo *ses)
1804{
1805 int xid;
1806 struct TCP_Server_Info *server = ses->server;
1807
Jeff Layton36988c72010-04-24 07:57:43 -04001808 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301809 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001810 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301811 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001812 return;
1813 }
1814
1815 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301816 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001817
1818 if (ses->status == CifsGood) {
1819 xid = GetXid();
1820 CIFSSMBLogoff(xid, ses);
1821 _FreeXid(xid);
1822 }
1823 sesInfoFree(ses);
1824 cifs_put_tcp_session(server);
1825}
1826
Jeff Layton36988c72010-04-24 07:57:43 -04001827static struct cifsSesInfo *
1828cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1829{
1830 int rc = -ENOMEM, xid;
1831 struct cifsSesInfo *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001832 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1833 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04001834
1835 xid = GetXid();
1836
Jeff Layton4ff67b72010-07-06 20:43:02 -04001837 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04001838 if (ses) {
1839 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1840
Jeff Layton36988c72010-04-24 07:57:43 -04001841 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001842 rc = cifs_negotiate_protocol(xid, ses);
1843 if (rc) {
1844 mutex_unlock(&ses->session_mutex);
1845 /* problem -- put our ses reference */
1846 cifs_put_smb_ses(ses);
1847 FreeXid(xid);
1848 return ERR_PTR(rc);
1849 }
Jeff Layton36988c72010-04-24 07:57:43 -04001850 if (ses->need_reconnect) {
1851 cFYI(1, "Session needs reconnect");
1852 rc = cifs_setup_session(xid, ses,
1853 volume_info->local_nls);
1854 if (rc) {
1855 mutex_unlock(&ses->session_mutex);
1856 /* problem -- put our reference */
1857 cifs_put_smb_ses(ses);
1858 FreeXid(xid);
1859 return ERR_PTR(rc);
1860 }
1861 }
1862 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04001863
1864 /* existing SMB ses has a server reference already */
1865 cifs_put_tcp_session(server);
Jeff Layton36988c72010-04-24 07:57:43 -04001866 FreeXid(xid);
1867 return ses;
1868 }
1869
1870 cFYI(1, "Existing smb sess not found");
1871 ses = sesInfoAlloc();
1872 if (ses == NULL)
1873 goto get_ses_fail;
1874
1875 /* new SMB session uses our server ref */
1876 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001877 if (server->dstaddr.ss_family == AF_INET6)
1878 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04001879 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001880 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04001881
1882 if (volume_info->username)
1883 strncpy(ses->userName, volume_info->username,
1884 MAX_USERNAME_SIZE);
1885
1886 /* volume_info->password freed at unmount */
1887 if (volume_info->password) {
1888 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1889 if (!ses->password)
1890 goto get_ses_fail;
1891 }
1892 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05001893 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1894 if (!ses->domainName)
1895 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04001896 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001897 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04001898 ses->linux_uid = volume_info->linux_uid;
1899 ses->overrideSecFlg = volume_info->secFlg;
1900
1901 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001902 rc = cifs_negotiate_protocol(xid, ses);
1903 if (!rc)
1904 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04001905 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00001906 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04001907 goto get_ses_fail;
1908
1909 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301910 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04001911 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301912 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04001913
1914 FreeXid(xid);
1915 return ses;
1916
1917get_ses_fail:
1918 sesInfoFree(ses);
1919 FreeXid(xid);
1920 return ERR_PTR(rc);
1921}
1922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05001924cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925{
1926 struct list_head *tmp;
1927 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301929 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001930 list_for_each(tmp, &ses->tcon_list) {
1931 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1932 if (tcon->tidStatus == CifsExiting)
1933 continue;
1934 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 continue;
1936
Jeff Laytonf1987b42008-11-15 11:12:47 -05001937 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301938 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 return tcon;
1940 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301941 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 return NULL;
1943}
1944
Jeff Laytonf1987b42008-11-15 11:12:47 -05001945static void
1946cifs_put_tcon(struct cifsTconInfo *tcon)
1947{
1948 int xid;
1949 struct cifsSesInfo *ses = tcon->ses;
1950
Jeff Laytond00c28d2010-04-24 07:57:44 -04001951 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301952 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001953 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301954 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001955 return;
1956 }
1957
1958 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301959 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001960
1961 xid = GetXid();
1962 CIFSSMBTDis(xid, tcon);
1963 _FreeXid(xid);
1964
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301965 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00001966 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05001967 cifs_put_smb_ses(ses);
1968}
1969
Jeff Laytond00c28d2010-04-24 07:57:44 -04001970static struct cifsTconInfo *
1971cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1972{
1973 int rc, xid;
1974 struct cifsTconInfo *tcon;
1975
1976 tcon = cifs_find_tcon(ses, volume_info->UNC);
1977 if (tcon) {
1978 cFYI(1, "Found match on UNC path");
1979 /* existing tcon already has a reference */
1980 cifs_put_smb_ses(ses);
1981 if (tcon->seal != volume_info->seal)
1982 cERROR(1, "transport encryption setting "
1983 "conflicts with existing tid");
1984 return tcon;
1985 }
1986
1987 tcon = tconInfoAlloc();
1988 if (tcon == NULL) {
1989 rc = -ENOMEM;
1990 goto out_fail;
1991 }
1992
1993 tcon->ses = ses;
1994 if (volume_info->password) {
1995 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
1996 if (!tcon->password) {
1997 rc = -ENOMEM;
1998 goto out_fail;
1999 }
2000 }
2001
2002 if (strchr(volume_info->UNC + 3, '\\') == NULL
2003 && strchr(volume_info->UNC + 3, '/') == NULL) {
2004 cERROR(1, "Missing share name");
2005 rc = -ENODEV;
2006 goto out_fail;
2007 }
2008
2009 /* BB Do we need to wrap session_mutex around
2010 * this TCon call and Unix SetFS as
2011 * we do on SessSetup and reconnect? */
2012 xid = GetXid();
2013 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2014 FreeXid(xid);
2015 cFYI(1, "CIFS Tcon rc = %d", rc);
2016 if (rc)
2017 goto out_fail;
2018
2019 if (volume_info->nodfs) {
2020 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2021 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2022 }
2023 tcon->seal = volume_info->seal;
2024 /* we can have only one retry value for a connection
2025 to a share so for resources mounted more than once
2026 to the same server share the last value passed in
2027 for the retry flag is used */
2028 tcon->retry = volume_info->retry;
2029 tcon->nocase = volume_info->nocase;
2030 tcon->local_lease = volume_info->local_lease;
2031
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302032 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002033 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302034 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002035
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302036 cifs_fscache_get_super_cookie(tcon);
2037
Jeff Laytond00c28d2010-04-24 07:57:44 -04002038 return tcon;
2039
2040out_fail:
2041 tconInfoFree(tcon);
2042 return ERR_PTR(rc);
2043}
2044
Jeff Layton9d002df2010-10-06 19:51:11 -04002045void
2046cifs_put_tlink(struct tcon_link *tlink)
2047{
2048 if (!tlink || IS_ERR(tlink))
2049 return;
2050
2051 if (!atomic_dec_and_test(&tlink->tl_count) ||
2052 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2053 tlink->tl_time = jiffies;
2054 return;
2055 }
2056
2057 if (!IS_ERR(tlink_tcon(tlink)))
2058 cifs_put_tcon(tlink_tcon(tlink));
2059 kfree(tlink);
2060 return;
2061}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002062
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063int
Steve French50c2f752007-07-13 00:33:32 +00002064get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2065 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00002066 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067{
2068 char *temp_unc;
2069 int rc = 0;
2070
2071 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00002072 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073
2074 if (pSesInfo->ipc_tid == 0) {
2075 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00002076 strnlen(pSesInfo->serverName,
2077 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 + 1 + 4 /* slash IPC$ */ + 2,
2079 GFP_KERNEL);
2080 if (temp_unc == NULL)
2081 return -ENOMEM;
2082 temp_unc[0] = '\\';
2083 temp_unc[1] = '\\';
2084 strcpy(temp_unc + 2, pSesInfo->serverName);
2085 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2086 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002087 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 kfree(temp_unc);
2089 }
2090 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00002091 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07002092 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00002093 /* BB map targetUNCs to dfs_info3 structures, here or
2094 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
2096 return rc;
2097}
2098
Jeff Layton09e50d52008-07-23 10:11:19 -04002099#ifdef CONFIG_DEBUG_LOCK_ALLOC
2100static struct lock_class_key cifs_key[2];
2101static struct lock_class_key cifs_slock_key[2];
2102
2103static inline void
2104cifs_reclassify_socket4(struct socket *sock)
2105{
2106 struct sock *sk = sock->sk;
2107 BUG_ON(sock_owned_by_user(sk));
2108 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2109 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2110}
2111
2112static inline void
2113cifs_reclassify_socket6(struct socket *sock)
2114{
2115 struct sock *sk = sock->sk;
2116 BUG_ON(sock_owned_by_user(sk));
2117 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2118 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2119}
2120#else
2121static inline void
2122cifs_reclassify_socket4(struct socket *sock)
2123{
2124}
2125
2126static inline void
2127cifs_reclassify_socket6(struct socket *sock)
2128{
2129}
2130#endif
2131
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002133static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134{
Steve French50c2f752007-07-13 00:33:32 +00002135 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136
Steve French50c2f752007-07-13 00:33:32 +00002137 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 /* mask a nibble at a time and encode */
2139 target[j] = 'A' + (0x0F & (source[i] >> 4));
2140 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002141 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 }
2143
2144}
2145
Ben Greear3eb9a882010-09-01 17:06:02 -07002146static int
2147bind_socket(struct TCP_Server_Info *server)
2148{
2149 int rc = 0;
2150 if (server->srcaddr.ss_family != AF_UNSPEC) {
2151 /* Bind to the specified local IP address */
2152 struct socket *socket = server->ssocket;
2153 rc = socket->ops->bind(socket,
2154 (struct sockaddr *) &server->srcaddr,
2155 sizeof(server->srcaddr));
2156 if (rc < 0) {
2157 struct sockaddr_in *saddr4;
2158 struct sockaddr_in6 *saddr6;
2159 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2160 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2161 if (saddr6->sin6_family == AF_INET6)
2162 cERROR(1, "cifs: "
2163 "Failed to bind to: %pI6c, error: %d\n",
2164 &saddr6->sin6_addr, rc);
2165 else
2166 cERROR(1, "cifs: "
2167 "Failed to bind to: %pI4, error: %d\n",
2168 &saddr4->sin_addr.s_addr, rc);
2169 }
2170 }
2171 return rc;
2172}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173
2174static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002175ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176{
2177 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002178 /*
2179 * some servers require RFC1001 sessinit before sending
2180 * negprot - BB check reconnection in case where second
2181 * sessinit is sent but no second negprot
2182 */
2183 struct rfc1002_session_packet *ses_init_buf;
2184 struct smb_hdr *smb_buf;
2185 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2186 GFP_KERNEL);
2187 if (ses_init_buf) {
2188 ses_init_buf->trailer.session_req.called_len = 32;
2189
2190 if (server->server_RFC1001_name &&
2191 server->server_RFC1001_name[0] != 0)
2192 rfc1002mangle(ses_init_buf->trailer.
2193 session_req.called_name,
2194 server->server_RFC1001_name,
2195 RFC1001_NAME_LEN_WITH_NULL);
2196 else
2197 rfc1002mangle(ses_init_buf->trailer.
2198 session_req.called_name,
2199 DEFAULT_CIFS_CALLED_NAME,
2200 RFC1001_NAME_LEN_WITH_NULL);
2201
2202 ses_init_buf->trailer.session_req.calling_len = 32;
2203
2204 /*
2205 * calling name ends in null (byte 16) from old smb
2206 * convention.
2207 */
2208 if (server->workstation_RFC1001_name &&
2209 server->workstation_RFC1001_name[0] != 0)
2210 rfc1002mangle(ses_init_buf->trailer.
2211 session_req.calling_name,
2212 server->workstation_RFC1001_name,
2213 RFC1001_NAME_LEN_WITH_NULL);
2214 else
2215 rfc1002mangle(ses_init_buf->trailer.
2216 session_req.calling_name,
2217 "LINUX_CIFS_CLNT",
2218 RFC1001_NAME_LEN_WITH_NULL);
2219
2220 ses_init_buf->trailer.session_req.scope1 = 0;
2221 ses_init_buf->trailer.session_req.scope2 = 0;
2222 smb_buf = (struct smb_hdr *)ses_init_buf;
2223
2224 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2225 smb_buf->smb_buf_length = 0x81000044;
2226 rc = smb_send(server, smb_buf, 0x44);
2227 kfree(ses_init_buf);
2228 /*
2229 * RFC1001 layer in at least one server
2230 * requires very short break before negprot
2231 * presumably because not expecting negprot
2232 * to follow so fast. This is a simple
2233 * solution that works without
2234 * complicating the code and causes no
2235 * significant slowing down on mount
2236 * for everyone else
2237 */
2238 usleep_range(1000, 2000);
2239 }
2240 /*
2241 * else the negprot may still work without this
2242 * even though malloc failed
2243 */
2244
2245 return rc;
2246}
2247
2248static int
2249generic_ip_connect(struct TCP_Server_Info *server)
2250{
2251 int rc = 0;
2252 unsigned short int sport;
2253 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002254 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002255 struct sockaddr *saddr;
2256
2257 saddr = (struct sockaddr *) &server->dstaddr;
2258
2259 if (server->dstaddr.ss_family == AF_INET6) {
2260 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2261 slen = sizeof(struct sockaddr_in6);
2262 sfamily = AF_INET6;
2263 } else {
2264 sport = ((struct sockaddr_in *) saddr)->sin_port;
2265 slen = sizeof(struct sockaddr_in);
2266 sfamily = AF_INET;
2267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002269 if (socket == NULL) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002270 rc = sock_create_kern(sfamily, SOCK_STREAM,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002271 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002273 cERROR(1, "Error %d creating socket", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002274 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002277
2278 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002279 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002280 server->ssocket = socket;
2281 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002282 if (sfamily == AF_INET6)
2283 cifs_reclassify_socket6(socket);
2284 else
2285 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 }
2287
Ben Greear3eb9a882010-09-01 17:06:02 -07002288 rc = bind_socket(server);
2289 if (rc < 0)
2290 return rc;
2291
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002292 rc = socket->ops->connect(socket, saddr, slen, 0);
2293 if (rc < 0) {
2294 cFYI(1, "Error %d connecting to server", rc);
Jeff Laytond5c56052008-12-01 18:42:33 -05002295 sock_release(socket);
2296 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 return rc;
2298 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00002299
Jeff Laytond5c56052008-12-01 18:42:33 -05002300 /*
2301 * Eventually check for other socket options to change from
2302 * the default. sock_setsockopt not used because it expects
2303 * user space buffer
2304 */
2305 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002306 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00002307
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002308 /* make the bufsizes depend on wsize/rsize and max requests */
2309 if (server->noautotune) {
2310 if (socket->sk->sk_sndbuf < (200 * 1024))
2311 socket->sk->sk_sndbuf = 200 * 1024;
2312 if (socket->sk->sk_rcvbuf < (140 * 1024))
2313 socket->sk->sk_rcvbuf = 140 * 1024;
2314 }
2315
Steve French6a5fa2362010-01-01 01:28:43 +00002316 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002317 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00002318 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2319 (char *)&val, sizeof(val));
2320 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002321 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002322 }
2323
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002324 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2325 socket->sk->sk_sndbuf,
2326 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2327
2328 if (sport == htons(RFC1001_PORT))
2329 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00002330
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 return rc;
2332}
2333
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002334static int
2335ip_connect(struct TCP_Server_Info *server)
2336{
2337 unsigned short int *sport;
2338 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2339 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2340
2341 if (server->dstaddr.ss_family == AF_INET6)
2342 sport = &addr6->sin6_port;
2343 else
2344 sport = &addr->sin_port;
2345
2346 if (*sport == 0) {
2347 int rc;
2348
2349 /* try with 445 port at first */
2350 *sport = htons(CIFS_PORT);
2351
2352 rc = generic_ip_connect(server);
2353 if (rc >= 0)
2354 return rc;
2355
2356 /* if it failed, try with 139 port */
2357 *sport = htons(RFC1001_PORT);
2358 }
2359
2360 return generic_ip_connect(server);
2361}
2362
Steve French50c2f752007-07-13 00:33:32 +00002363void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2364 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00002365{
2366 /* if we are reconnecting then should we check to see if
2367 * any requested capabilities changed locally e.g. via
2368 * remount but we can not do much about it here
2369 * if they have (even if we could detect it by the following)
2370 * Perhaps we could add a backpointer to array of sb from tcon
2371 * or if we change to make all sb to same share the same
2372 * sb as NFS - then we only have one backpointer to sb.
2373 * What if we wanted to mount the server share twice once with
2374 * and once without posixacls or posix paths? */
2375 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002376
Steve Frenchc18c8422007-07-18 23:21:09 +00002377 if (vol_info && vol_info->no_linux_ext) {
2378 tcon->fsUnixInfo.Capability = 0;
2379 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002380 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00002381 return;
2382 } else if (vol_info)
2383 tcon->unix_ext = 1; /* Unix Extensions supported */
2384
2385 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002386 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00002387 return;
2388 }
Steve French50c2f752007-07-13 00:33:32 +00002389
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002390 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00002391 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002392
Steve French8af18972007-02-14 04:42:51 +00002393 /* check for reconnect case in which we do not
2394 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002395 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002396 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002397 originally at mount time */
2398 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2399 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002400 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2401 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002402 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00002403 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002404 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002405 cERROR(1, "possible reconnect error");
2406 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00002407 }
Steve French8af18972007-02-14 04:42:51 +00002408 }
Steve French50c2f752007-07-13 00:33:32 +00002409
Steve French8af18972007-02-14 04:42:51 +00002410 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002411 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002412 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002413 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002414 cFYI(1, "negotiated posix acl support");
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002415 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002416 sb->s_flags |= MS_POSIXACL;
2417 }
2418
Steve French75865f8c2007-06-24 18:30:48 +00002419 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002420 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002421 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002422 cFYI(1, "negotiate posix pathnames");
Steve French75865f8c2007-06-24 18:30:48 +00002423 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002424 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002425 CIFS_MOUNT_POSIX_PATHS;
2426 }
Steve French50c2f752007-07-13 00:33:32 +00002427
Steve French984acfe2007-04-26 16:42:50 +00002428 /* We might be setting the path sep back to a different
2429 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002430 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002431 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002432 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002433
2434 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2435 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2436 CIFS_SB(sb)->rsize = 127 * 1024;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002437 cFYI(DBG2, "larger reads not supported by srv");
Steve French75865f8c2007-06-24 18:30:48 +00002438 }
2439 }
Steve French50c2f752007-07-13 00:33:32 +00002440
2441
Joe Perchesb6b38f72010-04-21 03:50:45 +00002442 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00002443#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002444 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002445 cFYI(1, "FCNTL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002446 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002447 cFYI(1, "EXTATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002448 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002449 cFYI(1, "POSIX path cap");
Steve French75865f8c2007-06-24 18:30:48 +00002450 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002451 cFYI(1, "XATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002452 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002453 cFYI(1, "POSIX ACL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002454 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002455 cFYI(1, "very large read cap");
Steve French75865f8c2007-06-24 18:30:48 +00002456 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002457 cFYI(1, "very large write cap");
Steve French8af18972007-02-14 04:42:51 +00002458#endif /* CIFS_DEBUG2 */
2459 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002460 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002461 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00002462 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002463 cERROR(1, "Negotiating Unix capabilities "
Steve French5a44b312007-09-20 15:16:24 +00002464 "with the server failed. Consider "
2465 "mounting with the Unix Extensions\n"
2466 "disabled, if problems are found, "
2467 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00002468 "option.");
Steve French5a44b312007-09-20 15:16:24 +00002469
Steve French8af18972007-02-14 04:42:51 +00002470 }
2471 }
2472}
2473
Steve French03a143c2008-02-14 06:38:30 +00002474static void
2475convert_delimiter(char *path, char delim)
2476{
2477 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002478 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002479
2480 if (path == NULL)
2481 return;
2482
Steve French582d21e2008-05-13 04:54:12 +00002483 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002484 old_delim = '\\';
2485 else
2486 old_delim = '/';
2487
Steve French03a143c2008-02-14 06:38:30 +00002488 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002489 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002490 path[i] = delim;
2491 }
2492}
2493
Steve French3b795212008-11-13 19:45:32 +00002494static void setup_cifs_sb(struct smb_vol *pvolume_info,
2495 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002496{
Jeff Layton2de970f2010-10-06 19:51:12 -04002497 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2498
Steve French3b795212008-11-13 19:45:32 +00002499 if (pvolume_info->rsize > CIFSMaxBufSize) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002500 cERROR(1, "rsize %d too large, using MaxBufSize",
2501 pvolume_info->rsize);
Steve French3b795212008-11-13 19:45:32 +00002502 cifs_sb->rsize = CIFSMaxBufSize;
2503 } else if ((pvolume_info->rsize) &&
2504 (pvolume_info->rsize <= CIFSMaxBufSize))
2505 cifs_sb->rsize = pvolume_info->rsize;
2506 else /* default */
2507 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002508
Steve French3b795212008-11-13 19:45:32 +00002509 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002510 cERROR(1, "wsize %d too large, using 4096 instead",
2511 pvolume_info->wsize);
Steve French3b795212008-11-13 19:45:32 +00002512 cifs_sb->wsize = 4096;
2513 } else if (pvolume_info->wsize)
2514 cifs_sb->wsize = pvolume_info->wsize;
2515 else
2516 cifs_sb->wsize = min_t(const int,
2517 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2518 127*1024);
2519 /* old default of CIFSMaxBufSize was too small now
2520 that SMB Write2 can send multiple pages in kvec.
2521 RFC1001 does not describe what happens when frame
2522 bigger than 128K is sent so use that as max in
2523 conjunction with 52K kvec constraint on arch with 4K
2524 page size */
2525
2526 if (cifs_sb->rsize < 2048) {
2527 cifs_sb->rsize = 2048;
2528 /* Windows ME may prefer this */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002529 cFYI(1, "readsize set to minimum: 2048");
Steve French3b795212008-11-13 19:45:32 +00002530 }
2531 /* calculate prepath */
2532 cifs_sb->prepath = pvolume_info->prepath;
2533 if (cifs_sb->prepath) {
2534 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2535 /* we can not convert the / to \ in the path
2536 separators in the prefixpath yet because we do not
2537 know (until reset_cifs_unix_caps is called later)
2538 whether POSIX PATH CAP is available. We normalize
2539 the / to \ after reset_cifs_unix_caps is called */
2540 pvolume_info->prepath = NULL;
2541 } else
2542 cifs_sb->prepathlen = 0;
2543 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2544 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2545 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2546 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002547 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2548 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00002549
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302550 cifs_sb->actimeo = pvolume_info->actimeo;
2551
Steve French3b795212008-11-13 19:45:32 +00002552 if (pvolume_info->noperm)
2553 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2554 if (pvolume_info->setuids)
2555 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2556 if (pvolume_info->server_ino)
2557 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2558 if (pvolume_info->remap)
2559 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2560 if (pvolume_info->no_xattr)
2561 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2562 if (pvolume_info->sfu_emul)
2563 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2564 if (pvolume_info->nobrl)
2565 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002566 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002567 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002568 if (pvolume_info->mand_lock)
2569 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002570 if (pvolume_info->cifs_acl)
2571 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2572 if (pvolume_info->override_uid)
2573 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2574 if (pvolume_info->override_gid)
2575 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2576 if (pvolume_info->dynperm)
2577 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05302578 if (pvolume_info->fsc)
2579 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04002580 if (pvolume_info->multiuser)
2581 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2582 CIFS_MOUNT_NO_PERM);
Steve French3b795212008-11-13 19:45:32 +00002583 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002584 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00002585 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2586 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02002587 if (pvolume_info->mfsymlinks) {
2588 if (pvolume_info->sfu_emul) {
2589 cERROR(1, "mount option mfsymlinks ignored if sfu "
2590 "mount option is used");
2591 } else {
2592 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2593 }
2594 }
Steve French3b795212008-11-13 19:45:32 +00002595
2596 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00002597 cERROR(1, "mount option dynperm ignored if cifsacl "
2598 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002599}
2600
Igor Mammedove4cce942009-02-10 14:10:26 +03002601static int
2602is_path_accessible(int xid, struct cifsTconInfo *tcon,
2603 struct cifs_sb_info *cifs_sb, const char *full_path)
2604{
2605 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03002606 FILE_ALL_INFO *pfile_info;
2607
Igor Mammedove4cce942009-02-10 14:10:26 +03002608 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2609 if (pfile_info == NULL)
2610 return -ENOMEM;
2611
2612 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2613 0 /* not legacy */, cifs_sb->local_nls,
2614 cifs_sb->mnt_cifs_flags &
2615 CIFS_MOUNT_MAP_SPECIAL_CHR);
2616 kfree(pfile_info);
2617 return rc;
2618}
2619
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002620static void
2621cleanup_volume_info(struct smb_vol **pvolume_info)
2622{
2623 struct smb_vol *volume_info;
2624
Dan Carpenterad6cca62010-04-26 12:10:06 +02002625 if (!pvolume_info || !*pvolume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002626 return;
2627
2628 volume_info = *pvolume_info;
2629 kzfree(volume_info->password);
2630 kfree(volume_info->UNC);
2631 kfree(volume_info->prepath);
2632 kfree(volume_info);
2633 *pvolume_info = NULL;
2634 return;
2635}
2636
Steve French2d6d5892009-04-09 00:36:44 +00002637#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002638/* build_path_to_root returns full path to root when
2639 * we do not have an exiting connection (tcon) */
2640static char *
2641build_unc_path_to_root(const struct smb_vol *volume_info,
2642 const struct cifs_sb_info *cifs_sb)
2643{
2644 char *full_path;
2645
2646 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2647 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2648 if (full_path == NULL)
2649 return ERR_PTR(-ENOMEM);
2650
2651 strncpy(full_path, volume_info->UNC, unc_len);
2652 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2653 int i;
2654 for (i = 0; i < unc_len; i++) {
2655 if (full_path[i] == '\\')
2656 full_path[i] = '/';
2657 }
2658 }
2659
2660 if (cifs_sb->prepathlen)
2661 strncpy(full_path + unc_len, cifs_sb->prepath,
2662 cifs_sb->prepathlen);
2663
2664 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2665 return full_path;
2666}
Steve French2d6d5892009-04-09 00:36:44 +00002667#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002668
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669int
2670cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002671 char *mount_data_global, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672{
Jeff Laytona2934c72009-12-03 08:09:41 -05002673 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002675 struct smb_vol *volume_info;
Jeff Laytona2934c72009-12-03 08:09:41 -05002676 struct cifsSesInfo *pSesInfo;
2677 struct cifsTconInfo *tcon;
2678 struct TCP_Server_Info *srvTcp;
Igor Mammedove4cce942009-02-10 14:10:26 +03002679 char *full_path;
Steve French2d6d5892009-04-09 00:36:44 +00002680 char *mount_data = mount_data_global;
Jeff Layton9d002df2010-10-06 19:51:11 -04002681 struct tcon_link *tlink;
Steve French2d6d5892009-04-09 00:36:44 +00002682#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002683 struct dfs_info3_param *referrals = NULL;
2684 unsigned int num_referrals = 0;
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002685 int referral_walks_count = 0;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002686try_mount_again:
Steve French2d6d5892009-04-09 00:36:44 +00002687#endif
Jeff Laytona2934c72009-12-03 08:09:41 -05002688 rc = 0;
2689 tcon = NULL;
2690 pSesInfo = NULL;
2691 srvTcp = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002692 full_path = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04002693 tlink = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694
2695 xid = GetXid();
2696
Jeff Layton7586b762008-12-01 18:41:49 -05002697 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2698 if (!volume_info) {
2699 rc = -ENOMEM;
2700 goto out;
2701 }
Steve French50c2f752007-07-13 00:33:32 +00002702
Jeff Layton7586b762008-12-01 18:41:49 -05002703 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002704 rc = -EINVAL;
2705 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 }
2707
Jeff Layton7586b762008-12-01 18:41:49 -05002708 if (volume_info->nullauth) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002709 cFYI(1, "null user");
Jeff Layton7586b762008-12-01 18:41:49 -05002710 volume_info->username = "";
2711 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002713 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002715 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002716 /* In userspace mount helper we can get user name from alternate
2717 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002718 rc = -EINVAL;
2719 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 }
2721
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002723 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002724 /* load_nls_default cannot return null */
2725 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002727 volume_info->local_nls = load_nls(volume_info->iocharset);
2728 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002729 cERROR(1, "CIFS mount error: iocharset %s not found",
2730 volume_info->iocharset);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002731 rc = -ELIBACC;
2732 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 }
2734 }
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002735 cifs_sb->local_nls = volume_info->local_nls;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
Jeff Layton63c038c2008-12-01 18:41:46 -05002737 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002738 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002739 if (IS_ERR(srvTcp)) {
2740 rc = PTR_ERR(srvTcp);
2741 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 }
2743
Jeff Layton36988c72010-04-24 07:57:43 -04002744 /* get a reference to a SMB session */
2745 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2746 if (IS_ERR(pSesInfo)) {
2747 rc = PTR_ERR(pSesInfo);
2748 pSesInfo = NULL;
2749 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 }
Steve French50c2f752007-07-13 00:33:32 +00002751
Jeff Laytond00c28d2010-04-24 07:57:44 -04002752 setup_cifs_sb(volume_info, cifs_sb);
2753 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2754 sb->s_maxbytes = MAX_LFS_FILESIZE;
2755 else
2756 sb->s_maxbytes = MAX_NON_LFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757
Steve French8af18972007-02-14 04:42:51 +00002758 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 sb->s_time_gran = 100;
2760
Jeff Laytond00c28d2010-04-24 07:57:44 -04002761 /* search for existing tcon to this server share */
2762 tcon = cifs_get_tcon(pSesInfo, volume_info);
2763 if (IS_ERR(tcon)) {
2764 rc = PTR_ERR(tcon);
2765 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002766 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002767 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002768
Steve Frenchd82c2df2008-11-15 00:07:26 +00002769 /* do not care if following two calls succeed - informational */
2770 if (!tcon->ipc) {
2771 CIFSSMBQFSDeviceInfo(xid, tcon);
2772 CIFSSMBQFSAttributeInfo(xid, tcon);
2773 }
2774
2775 /* tell server which Unix caps we support */
2776 if (tcon->ses->capabilities & CAP_UNIX)
2777 /* reset of caps checks mount to see if unix extensions
2778 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002779 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002780 else
2781 tcon->unix_ext = 0; /* server does not support them */
2782
2783 /* convert forward to back slashes in prepath here if needed */
2784 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2785 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2786
2787 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2788 cifs_sb->rsize = 1024 * 127;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002789 cFYI(DBG2, "no very large read support, rsize now 127K");
Steve Frenchd82c2df2008-11-15 00:07:26 +00002790 }
2791 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2792 cifs_sb->wsize = min(cifs_sb->wsize,
2793 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2794 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2795 cifs_sb->rsize = min(cifs_sb->rsize,
2796 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002798remote_path_check:
2799 /* check if a whole path (including prepath) is not remote */
2800 if (!rc && cifs_sb->prepathlen && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002801 /* build_path_to_root works only when we have a valid tcon */
Jeff Layton7d161b72010-12-07 02:10:35 -05002802 full_path = cifs_build_path_to_root(cifs_sb, tcon);
Igor Mammedove4cce942009-02-10 14:10:26 +03002803 if (full_path == NULL) {
2804 rc = -ENOMEM;
2805 goto mount_fail_check;
2806 }
2807 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Jeff Layton03ceace2010-12-06 21:07:33 -05002808 if (rc != 0 && rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002809 kfree(full_path);
2810 goto mount_fail_check;
2811 }
2812 kfree(full_path);
2813 }
2814
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002815 /* get referral if needed */
2816 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00002817#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002818 if (referral_walks_count > MAX_NESTED_LINKS) {
2819 /*
2820 * BB: when we implement proper loop detection,
2821 * we will remove this check. But now we need it
2822 * to prevent an indefinite loop if 'DFS tree' is
2823 * misconfigured (i.e. has loops).
2824 */
2825 rc = -ELOOP;
2826 goto mount_fail_check;
2827 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002828 /* convert forward to back slashes in prepath here if needed */
2829 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2830 convert_delimiter(cifs_sb->prepath,
2831 CIFS_DIR_SEP(cifs_sb));
2832 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2833 if (IS_ERR(full_path)) {
2834 rc = PTR_ERR(full_path);
2835 goto mount_fail_check;
2836 }
2837
Joe Perchesb6b38f72010-04-21 03:50:45 +00002838 cFYI(1, "Getting referral for: %s", full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002839 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2840 cifs_sb->local_nls, &num_referrals, &referrals,
2841 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2842 if (!rc && num_referrals > 0) {
2843 char *fake_devname = NULL;
2844
2845 if (mount_data != mount_data_global)
2846 kfree(mount_data);
Jeff Layton7b91e262009-07-23 15:22:30 -04002847
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002848 mount_data = cifs_compose_mount_options(
2849 cifs_sb->mountdata, full_path + 1,
2850 referrals, &fake_devname);
Jeff Layton7b91e262009-07-23 15:22:30 -04002851
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002852 free_dfs_info_array(referrals, num_referrals);
Jeff Layton7b91e262009-07-23 15:22:30 -04002853 kfree(fake_devname);
2854 kfree(full_path);
2855
2856 if (IS_ERR(mount_data)) {
2857 rc = PTR_ERR(mount_data);
2858 mount_data = NULL;
2859 goto mount_fail_check;
2860 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002861
2862 if (tcon)
2863 cifs_put_tcon(tcon);
2864 else if (pSesInfo)
2865 cifs_put_smb_ses(pSesInfo);
2866
2867 cleanup_volume_info(&volume_info);
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002868 referral_walks_count++;
Jeff Laytona2934c72009-12-03 08:09:41 -05002869 FreeXid(xid);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002870 goto try_mount_again;
2871 }
Steve Frenchd036f502009-04-03 03:12:08 +00002872#else /* No DFS support, return error on mount */
2873 rc = -EOPNOTSUPP;
2874#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002875 }
2876
Jeff Layton9d002df2010-10-06 19:51:11 -04002877 if (rc)
2878 goto mount_fail_check;
2879
2880 /* now, hang the tcon off of the superblock */
2881 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2882 if (tlink == NULL) {
2883 rc = -ENOMEM;
2884 goto mount_fail_check;
2885 }
2886
Jeff Laytonb647c352010-10-28 11:16:44 -04002887 tlink->tl_uid = pSesInfo->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04002888 tlink->tl_tcon = tcon;
2889 tlink->tl_time = jiffies;
2890 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2891 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2892
Jeff Layton413e6612010-10-28 13:33:38 -04002893 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04002894 spin_lock(&cifs_sb->tlink_tree_lock);
2895 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2896 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04002897
Jeff Layton2de970f2010-10-06 19:51:12 -04002898 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2899 TLINK_IDLE_EXPIRE);
2900
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002901mount_fail_check:
2902 /* on error free sesinfo and tcon struct if needed */
2903 if (rc) {
2904 if (mount_data != mount_data_global)
2905 kfree(mount_data);
2906 /* If find_unc succeeded then rc == 0 so we can not end */
2907 /* up accidently freeing someone elses tcon struct */
2908 if (tcon)
2909 cifs_put_tcon(tcon);
2910 else if (pSesInfo)
2911 cifs_put_smb_ses(pSesInfo);
2912 else
2913 cifs_put_tcp_session(srvTcp);
2914 goto out;
2915 }
2916
Jeff Layton7586b762008-12-01 18:41:49 -05002917 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 (in which case it is not needed anymore) but when new sesion is created
2919 the password ptr is put in the new session structure (in which case the
2920 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002921out:
2922 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002923 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 FreeXid(xid);
2925 return rc;
2926}
2927
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928int
2929CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2930 const char *tree, struct cifsTconInfo *tcon,
2931 const struct nls_table *nls_codepage)
2932{
2933 struct smb_hdr *smb_buffer;
2934 struct smb_hdr *smb_buffer_response;
2935 TCONX_REQ *pSMB;
2936 TCONX_RSP *pSMBr;
2937 unsigned char *bcc_ptr;
2938 int rc = 0;
Jeff Laytoncc20c032009-04-30 07:16:21 -04002939 int length, bytes_left;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 __u16 count;
2941
2942 if (ses == NULL)
2943 return -EIO;
2944
2945 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00002946 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00002948
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 smb_buffer_response = smb_buffer;
2950
2951 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2952 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07002953
2954 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 smb_buffer->Uid = ses->Suid;
2956 pSMB = (TCONX_REQ *) smb_buffer;
2957 pSMBr = (TCONX_RSP *) smb_buffer_response;
2958
2959 pSMB->AndXCommand = 0xFF;
2960 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002962 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08002963 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00002964 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08002965 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00002966 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08002967 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00002968 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08002969 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2970 specified as required (when that support is added to
2971 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00002972 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08002973 by Samba (not sure whether other servers allow
2974 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00002975#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04002976 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05002977 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05002978 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05002979 ses->server->secMode &
2980 SECMODE_PW_ENCRYPT ? true : false,
2981 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00002982 else
2983#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05002984 SMBNTencrypt(tcon->password, ses->server->cryptkey, bcc_ptr);
Steve Frencheeac8042006-01-13 21:34:58 -08002985
Steve French7c7b25b2006-06-01 19:20:10 +00002986 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002987 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00002988 /* must align unicode strings */
2989 *bcc_ptr = 0; /* null byte password */
2990 bcc_ptr++;
2991 }
Steve Frencheeac8042006-01-13 21:34:58 -08002992 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993
Steve French50c2f752007-07-13 00:33:32 +00002994 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00002995 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2997
2998 if (ses->capabilities & CAP_STATUS32) {
2999 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3000 }
3001 if (ses->capabilities & CAP_DFS) {
3002 smb_buffer->Flags2 |= SMBFLG2_DFS;
3003 }
3004 if (ses->capabilities & CAP_UNICODE) {
3005 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3006 length =
Steve French50c2f752007-07-13 00:33:32 +00003007 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3008 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003009 (/* server len*/ + 256 /* share len */), nls_codepage);
3010 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011 bcc_ptr += 2; /* skip trailing null */
3012 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 strcpy(bcc_ptr, tree);
3014 bcc_ptr += strlen(tree) + 1;
3015 }
3016 strcpy(bcc_ptr, "?????");
3017 bcc_ptr += strlen("?????");
3018 bcc_ptr += 1;
3019 count = bcc_ptr - &pSMB->Password[0];
3020 pSMB->hdr.smb_buf_length += count;
3021 pSMB->ByteCount = cpu_to_le16(count);
3022
Steve French133672e2007-11-13 22:41:37 +00003023 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3024 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 /* above now done in SendReceive */
3027 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003028 bool is_unicode;
3029
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003031 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 tcon->tid = smb_buffer_response->Tid;
3033 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003034 bytes_left = BCC(smb_buffer_response);
3035 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003036 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3037 is_unicode = true;
3038 else
3039 is_unicode = false;
3040
Jeff Laytoncc20c032009-04-30 07:16:21 -04003041
Steve French50c2f752007-07-13 00:33:32 +00003042 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003043 if (length == 3) {
3044 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3045 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003046 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003047 tcon->ipc = 1;
3048 }
3049 } else if (length == 2) {
3050 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3051 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003052 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003053 }
3054 }
Steve French50c2f752007-07-13 00:33:32 +00003055 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003056 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003058
3059 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003060 kfree(tcon->nativeFileSystem);
Steve Frenchd185cda2009-04-30 17:45:10 +00003061 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003062 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003063 nls_codepage);
3064
Joe Perchesb6b38f72010-04-21 03:50:45 +00003065 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003066
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003067 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003068 (smb_buffer_response->WordCount == 7))
3069 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003070 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3071 else
3072 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003073 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003075 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 ses->ipc_tid = smb_buffer_response->Tid;
3077 }
3078
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003079 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 return rc;
3081}
3082
3083int
3084cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3085{
Jeff Laytonb647c352010-10-28 11:16:44 -04003086 struct rb_root *root = &cifs_sb->tlink_tree;
3087 struct rb_node *node;
3088 struct tcon_link *tlink;
Steve French50c2f752007-07-13 00:33:32 +00003089 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090
Jeff Layton2de970f2010-10-06 19:51:12 -04003091 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3092
Jeff Laytonb647c352010-10-28 11:16:44 -04003093 spin_lock(&cifs_sb->tlink_tree_lock);
3094 while ((node = rb_first(root))) {
3095 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3096 cifs_get_tlink(tlink);
3097 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3098 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003099
Jeff Laytonb647c352010-10-28 11:16:44 -04003100 spin_unlock(&cifs_sb->tlink_tree_lock);
3101 cifs_put_tlink(tlink);
3102 spin_lock(&cifs_sb->tlink_tree_lock);
3103 }
3104 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003105
Steve French2fe87f02006-09-21 07:02:52 +00003106 tmp = cifs_sb->prepath;
3107 cifs_sb->prepathlen = 0;
3108 cifs_sb->prepath = NULL;
3109 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110
Jeff Layton9d002df2010-10-06 19:51:11 -04003111 return 0;
Steve French50c2f752007-07-13 00:33:32 +00003112}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113
Jeff Layton198b5682010-04-24 07:57:48 -04003114int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115{
3116 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003117 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118
Jeff Layton198b5682010-04-24 07:57:48 -04003119 /* only send once per connect */
3120 if (server->maxBuf != 0)
3121 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122
Jeff Layton198b5682010-04-24 07:57:48 -04003123 rc = CIFSSMBNegotiate(xid, ses);
3124 if (rc == -EAGAIN) {
3125 /* retry only once on 1st time connection */
3126 rc = CIFSSMBNegotiate(xid, ses);
3127 if (rc == -EAGAIN)
3128 rc = -EHOSTDOWN;
3129 }
3130 if (rc == 0) {
3131 spin_lock(&GlobalMid_Lock);
3132 if (server->tcpStatus != CifsExiting)
3133 server->tcpStatus = CifsGood;
3134 else
3135 rc = -EHOSTDOWN;
3136 spin_unlock(&GlobalMid_Lock);
3137
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 }
Steve French26b994f2008-08-06 05:11:33 +00003139
Jeff Layton198b5682010-04-24 07:57:48 -04003140 return rc;
3141}
Steve French26b994f2008-08-06 05:11:33 +00003142
Jeff Layton198b5682010-04-24 07:57:48 -04003143
3144int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3145 struct nls_table *nls_info)
3146{
3147 int rc = 0;
3148 struct TCP_Server_Info *server = ses->server;
3149
3150 ses->flags = 0;
3151 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003152 if (linuxExtEnabled == 0)
Jeff Layton198b5682010-04-24 07:57:48 -04003153 ses->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00003154
Joe Perchesb6b38f72010-04-21 03:50:45 +00003155 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3156 server->secMode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003157
Jeff Layton198b5682010-04-24 07:57:48 -04003158 rc = CIFS_SessSetup(xid, ses, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00003159 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003160 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00003161 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003162 mutex_lock(&ses->server->srv_mutex);
3163 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003164 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003165 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003166 server->sequence_number = 0x2;
3167 server->session_estab = true;
3168 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003169 }
3170 mutex_unlock(&server->srv_mutex);
3171
Joe Perchesb6b38f72010-04-21 03:50:45 +00003172 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00003173 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003174 ses->status = CifsGood;
3175 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003176 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003177 }
3178
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003179 kfree(ses->auth_key.response);
3180 ses->auth_key.response = NULL;
3181 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003182 kfree(ses->ntlmssp);
3183 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003184
Linus Torvalds1da177e2005-04-16 15:20:36 -07003185 return rc;
3186}
3187
Steve Frenchd2445552010-10-08 03:38:46 +00003188static struct cifsTconInfo *
Jeff Layton9d002df2010-10-06 19:51:11 -04003189cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3190{
3191 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3192 struct cifsSesInfo *ses;
3193 struct cifsTconInfo *tcon = NULL;
3194 struct smb_vol *vol_info;
3195 char username[MAX_USERNAME_SIZE + 1];
3196
3197 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3198 if (vol_info == NULL) {
3199 tcon = ERR_PTR(-ENOMEM);
3200 goto out;
3201 }
3202
3203 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3204 vol_info->username = username;
3205 vol_info->local_nls = cifs_sb->local_nls;
3206 vol_info->linux_uid = fsuid;
3207 vol_info->cred_uid = fsuid;
3208 vol_info->UNC = master_tcon->treeName;
3209 vol_info->retry = master_tcon->retry;
3210 vol_info->nocase = master_tcon->nocase;
3211 vol_info->local_lease = master_tcon->local_lease;
3212 vol_info->no_linux_ext = !master_tcon->unix_ext;
3213
3214 /* FIXME: allow for other secFlg settings */
3215 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3216
3217 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303218 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003219 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303220 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003221
3222 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3223 if (IS_ERR(ses)) {
3224 tcon = (struct cifsTconInfo *)ses;
3225 cifs_put_tcp_session(master_tcon->ses->server);
3226 goto out;
3227 }
3228
3229 tcon = cifs_get_tcon(ses, vol_info);
3230 if (IS_ERR(tcon)) {
3231 cifs_put_smb_ses(ses);
3232 goto out;
3233 }
3234
3235 if (ses->capabilities & CAP_UNIX)
3236 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3237out:
3238 kfree(vol_info);
3239
3240 return tcon;
3241}
3242
Jeff Layton413e6612010-10-28 13:33:38 -04003243static inline struct tcon_link *
Jeff Layton9d002df2010-10-06 19:51:11 -04003244cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3245{
Jeff Layton413e6612010-10-28 13:33:38 -04003246 return cifs_sb->master_tlink;
Jeff Layton9d002df2010-10-06 19:51:11 -04003247}
3248
3249struct cifsTconInfo *
3250cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3251{
3252 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3253}
3254
3255static int
3256cifs_sb_tcon_pending_wait(void *unused)
3257{
3258 schedule();
3259 return signal_pending(current) ? -ERESTARTSYS : 0;
3260}
3261
Jeff Laytonb647c352010-10-28 11:16:44 -04003262/* find and return a tlink with given uid */
3263static struct tcon_link *
3264tlink_rb_search(struct rb_root *root, uid_t uid)
3265{
3266 struct rb_node *node = root->rb_node;
3267 struct tcon_link *tlink;
3268
3269 while (node) {
3270 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3271
3272 if (tlink->tl_uid > uid)
3273 node = node->rb_left;
3274 else if (tlink->tl_uid < uid)
3275 node = node->rb_right;
3276 else
3277 return tlink;
3278 }
3279 return NULL;
3280}
3281
3282/* insert a tcon_link into the tree */
3283static void
3284tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3285{
3286 struct rb_node **new = &(root->rb_node), *parent = NULL;
3287 struct tcon_link *tlink;
3288
3289 while (*new) {
3290 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3291 parent = *new;
3292
3293 if (tlink->tl_uid > new_tlink->tl_uid)
3294 new = &((*new)->rb_left);
3295 else
3296 new = &((*new)->rb_right);
3297 }
3298
3299 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3300 rb_insert_color(&new_tlink->tl_rbnode, root);
3301}
3302
Jeff Layton9d002df2010-10-06 19:51:11 -04003303/*
3304 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3305 * current task.
3306 *
3307 * If the superblock doesn't refer to a multiuser mount, then just return
3308 * the master tcon for the mount.
3309 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05303310 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04003311 * exists, then check to see if it's pending construction. If it is then wait
3312 * for construction to complete. Once it's no longer pending, check to see if
3313 * it failed and either return an error or retry construction, depending on
3314 * the timeout.
3315 *
3316 * If one doesn't exist then insert a new tcon_link struct into the tree and
3317 * try to construct a new one.
3318 */
3319struct tcon_link *
3320cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3321{
3322 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04003323 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04003324 struct tcon_link *tlink, *newtlink;
3325
3326 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3327 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3328
3329 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003330 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003331 if (tlink)
3332 cifs_get_tlink(tlink);
3333 spin_unlock(&cifs_sb->tlink_tree_lock);
3334
3335 if (tlink == NULL) {
3336 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3337 if (newtlink == NULL)
3338 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04003339 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003340 newtlink->tl_tcon = ERR_PTR(-EACCES);
3341 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3342 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3343 cifs_get_tlink(newtlink);
3344
Jeff Layton9d002df2010-10-06 19:51:11 -04003345 spin_lock(&cifs_sb->tlink_tree_lock);
3346 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04003347 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003348 if (tlink) {
3349 cifs_get_tlink(tlink);
3350 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003351 kfree(newtlink);
3352 goto wait_for_construction;
3353 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003354 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003355 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3356 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003357 } else {
3358wait_for_construction:
3359 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3360 cifs_sb_tcon_pending_wait,
3361 TASK_INTERRUPTIBLE);
3362 if (ret) {
3363 cifs_put_tlink(tlink);
3364 return ERR_PTR(ret);
3365 }
3366
3367 /* if it's good, return it */
3368 if (!IS_ERR(tlink->tl_tcon))
3369 return tlink;
3370
3371 /* return error if we tried this already recently */
3372 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3373 cifs_put_tlink(tlink);
3374 return ERR_PTR(-EACCES);
3375 }
3376
3377 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3378 goto wait_for_construction;
3379 }
3380
3381 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3382 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3383 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3384
3385 if (IS_ERR(tlink->tl_tcon)) {
3386 cifs_put_tlink(tlink);
3387 return ERR_PTR(-EACCES);
3388 }
3389
3390 return tlink;
3391}
Jeff Layton2de970f2010-10-06 19:51:12 -04003392
3393/*
3394 * periodic workqueue job that scans tcon_tree for a superblock and closes
3395 * out tcons.
3396 */
3397static void
3398cifs_prune_tlinks(struct work_struct *work)
3399{
3400 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3401 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04003402 struct rb_root *root = &cifs_sb->tlink_tree;
3403 struct rb_node *node = rb_first(root);
3404 struct rb_node *tmp;
3405 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04003406
Jeff Laytonb647c352010-10-28 11:16:44 -04003407 /*
3408 * Because we drop the spinlock in the loop in order to put the tlink
3409 * it's not guarded against removal of links from the tree. The only
3410 * places that remove entries from the tree are this function and
3411 * umounts. Because this function is non-reentrant and is canceled
3412 * before umount can proceed, this is safe.
3413 */
3414 spin_lock(&cifs_sb->tlink_tree_lock);
3415 node = rb_first(root);
3416 while (node != NULL) {
3417 tmp = node;
3418 node = rb_next(tmp);
3419 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3420
3421 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3422 atomic_read(&tlink->tl_count) != 0 ||
3423 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3424 continue;
3425
3426 cifs_get_tlink(tlink);
3427 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3428 rb_erase(tmp, root);
3429
Jeff Layton2de970f2010-10-06 19:51:12 -04003430 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003431 cifs_put_tlink(tlink);
3432 spin_lock(&cifs_sb->tlink_tree_lock);
3433 }
3434 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04003435
3436 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3437 TLINK_IDLE_EXPIRE);
3438}