blob: 63ea83ff687f7664b7205038cebdcb6184b831e8 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/pagemap.h>
27#include <linux/ctype.h>
28#include <linux/utsname.h>
29#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070030#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070031#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000032#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070033#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080034#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040035#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
37#include <asm/processor.h>
Jeff Layton50b64e32009-06-02 06:55:20 -040038#include <linux/inet.h>
Steve French0e2beda2009-01-30 21:24:41 +000039#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "cifspdu.h"
41#include "cifsglob.h"
42#include "cifsproto.h"
43#include "cifs_unicode.h"
44#include "cifs_debug.h"
45#include "cifs_fs_sb.h"
46#include "ntlmssp.h"
47#include "nterr.h"
48#include "rfc1002pdu.h"
Steve Frencha2653eb2005-11-10 15:33:38 -080049#include "cn_cifs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51#define CIFS_PORT 445
52#define RFC1001_PORT 139
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 unsigned char *p24);
56
57extern mempool_t *cifs_req_poolp;
58
59struct smb_vol {
60 char *username;
61 char *password;
62 char *domainname;
63 char *UNC;
64 char *UNCip;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 char *iocharset; /* local code page for mapping to and from Unicode */
66 char source_rfc1001_name[16]; /* netbios name of client */
Steve Frencha10faeb22005-08-22 21:38:31 -070067 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 uid_t linux_uid;
69 gid_t linux_gid;
70 mode_t file_mode;
71 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000072 unsigned secFlg;
Steve French4b18f2a2008-04-29 00:06:05 +000073 bool retry:1;
74 bool intr:1;
75 bool setuids:1;
76 bool override_uid:1;
77 bool override_gid:1;
Jeff Laytond0a9c072008-05-12 22:23:49 +000078 bool dynperm:1;
Steve French4b18f2a2008-04-29 00:06:05 +000079 bool noperm:1;
80 bool no_psx_acl:1; /* set if posix acl support should be disabled */
81 bool cifs_acl:1;
82 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
83 bool server_ino:1; /* use inode numbers from server ie UniqueId */
84 bool direct_io:1;
Steve French95b1cb92008-05-15 16:44:38 +000085 bool remap:1; /* set to remap seven reserved chars in filenames */
86 bool posix_paths:1; /* unset to not ask for posix pathnames. */
Steve French4b18f2a2008-04-29 00:06:05 +000087 bool no_linux_ext:1;
88 bool sfu_emul:1;
Steve French95b1cb92008-05-15 16:44:38 +000089 bool nullauth:1; /* attempt to authenticate with null user */
90 bool nocase:1; /* request case insensitive filenames */
91 bool nobrl:1; /* disable sending byte range locks to srv */
Steve French13a6e422008-12-02 17:24:33 +000092 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
Steve French95b1cb92008-05-15 16:44:38 +000093 bool seal:1; /* request transport encryption on share */
Steve French84210e92008-10-23 04:42:37 +000094 bool nodfs:1; /* Do not request DFS, even if available */
95 bool local_lease:1; /* check leases only on local system, not remote */
Steve Frenchedf1ae42008-10-29 00:47:57 +000096 bool noblocksnd:1;
97 bool noautotune:1;
Steve Frenchbe652442009-02-23 15:21:59 +000098 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 unsigned int rsize;
100 unsigned int wsize;
101 unsigned int sockopt;
102 unsigned short int port;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000103 char *prepath;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104};
105
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500106static int ipv4_connect(struct TCP_Server_Info *server);
Jeff Laytond5c56052008-12-01 18:42:33 -0500107static int ipv6_connect(struct TCP_Server_Info *server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Jeff Laytond5c56052008-12-01 18:42:33 -0500109/*
110 * cifs tcp session reconnection
111 *
112 * mark tcp session as reconnecting so temporarily locked
113 * mark all smb sessions as reconnecting for tcp session
114 * reconnect tcp session
115 * wake up waiters on reconnection? - (not needed currently)
116 */
Steve French2cd646a2006-09-28 19:43:08 +0000117static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118cifs_reconnect(struct TCP_Server_Info *server)
119{
120 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500121 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000124 struct mid_q_entry *mid_entry;
Steve French50c2f752007-07-13 00:33:32 +0000125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000127 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000128 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
131 return rc;
132 } else
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
135 server->maxBuf = 0;
136
Steve Frenche4eb2952005-04-28 22:41:09 -0700137 cFYI(1, ("Reconnecting tcp session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
Jeff Layton14fbf502008-11-14 13:53:46 -0500141 read_lock(&cifs_tcp_ses_lock);
142 list_for_each(tmp, &server->smb_ses_list) {
143 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
144 ses->need_reconnect = true;
145 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500146 list_for_each(tmp2, &ses->tcon_list) {
147 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
148 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500151 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 /* do not want to be sending data on a socket we are freeing */
Jeff Layton72ca5452008-12-01 07:09:36 -0500153 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000154 if (server->ssocket) {
Steve French467a8f82007-06-27 22:41:32 +0000155 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 server->ssocket->flags));
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800157 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000158 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000159 server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 server->ssocket->flags));
161 sock_release(server->ssocket);
162 server->ssocket = NULL;
163 }
164
165 spin_lock(&GlobalMid_Lock);
166 list_for_each(tmp, &server->pending_mid_q) {
167 mid_entry = list_entry(tmp, struct
168 mid_q_entry,
169 qhead);
Steve Frenchad8b15f2008-08-08 21:10:16 +0000170 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French09d1db52005-04-28 22:41:08 -0700171 /* Mark other intransit requests as needing
172 retry so we do not immediately mark the
173 session bad again (ie after we reconnect
174 below) as they timeout too */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000175 mid_entry->midState = MID_RETRY_NEEDED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
177 }
178 spin_unlock(&GlobalMid_Lock);
Jeff Layton72ca5452008-12-01 07:09:36 -0500179 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Jeff Layton469ee612008-10-16 18:46:39 +0000181 while ((server->tcpStatus != CifsExiting) &&
182 (server->tcpStatus != CifsGood)) {
Steve French6c3d8902006-07-31 22:46:20 +0000183 try_to_freeze();
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500184 if (server->addr.sockAddr6.sin6_family == AF_INET6)
Jeff Laytond5c56052008-12-01 18:42:33 -0500185 rc = ipv6_connect(server);
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500186 else
187 rc = ipv4_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000188 if (rc) {
189 cFYI(1, ("reconnect error %d", rc));
Steve French0cb766a2005-04-28 22:41:11 -0700190 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 } else {
192 atomic_inc(&tcpSesReconnectCount);
193 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000194 if (server->tcpStatus != CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 server->tcpStatus = CifsGood;
Steve Frenchad009ac2005-04-28 22:41:05 -0700196 server->sequence_number = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000197 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 /* atomic_set(&server->inFlight,0);*/
199 wake_up(&server->response_q);
200 }
201 }
202 return rc;
203}
204
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000205/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700206 return codes:
207 0 not a transact2, or all data present
208 >0 transact2 with that much data missing
209 -EINVAL = invalid transact2
210
211 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000212static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700213{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000214 struct smb_t2_rsp *pSMBt;
215 int total_data_size;
Steve Frenche4eb2952005-04-28 22:41:09 -0700216 int data_in_this_rsp;
217 int remaining;
218
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000219 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700220 return 0;
221
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000222 /* check for plausible wct, bcc and t2 data and parm sizes */
223 /* check for parm and data offset going beyond end of smb */
224 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Steve French467a8f82007-06-27 22:41:32 +0000225 cFYI(1, ("invalid transact2 word count"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700226 return -EINVAL;
227 }
228
229 pSMBt = (struct smb_t2_rsp *)pSMB;
230
231 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
232 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
233
234 remaining = total_data_size - data_in_this_rsp;
235
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000236 if (remaining == 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700237 return 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000238 else if (remaining < 0) {
Steve French467a8f82007-06-27 22:41:32 +0000239 cFYI(1, ("total data %d smaller than data in frame %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700240 total_data_size, data_in_this_rsp));
241 return -EINVAL;
242 } else {
Steve French467a8f82007-06-27 22:41:32 +0000243 cFYI(1, ("missing %d bytes from transact2, check next response",
Steve Frenche4eb2952005-04-28 22:41:09 -0700244 remaining));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000245 if (total_data_size > maxBufSize) {
246 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
247 total_data_size, maxBufSize));
248 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700249 }
250 return remaining;
251 }
252}
253
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000254static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700255{
256 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
257 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
258 int total_data_size;
259 int total_in_buf;
260 int remaining;
261 int total_in_buf2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000262 char *data_area_of_target;
263 char *data_area_of_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700264 __u16 byte_count;
265
266 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
267
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000268 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
Steve French63135e02007-07-17 17:34:02 +0000269 cFYI(1, ("total data size of primary and secondary t2 differ"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700270 }
271
272 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
273
274 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000275
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000276 if (remaining < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700277 return -EINVAL;
278
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000279 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700280 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000281
Steve Frenche4eb2952005-04-28 22:41:09 -0700282 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000283 if (remaining < total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000284 cFYI(1, ("transact2 2nd response contains too much data"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700285 }
286
287 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000288 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Steve Frenche4eb2952005-04-28 22:41:09 -0700289 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
290 /* validate target area */
291
292 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000293 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700294
295 data_area_of_target += total_in_buf;
296
297 /* copy second buffer into end of first buffer */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000298 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
Steve Frenche4eb2952005-04-28 22:41:09 -0700299 total_in_buf += total_in_buf2;
300 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
301 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
302 byte_count += total_in_buf2;
303 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
304
Steve French70ca7342005-09-22 16:32:06 -0700305 byte_count = pTargetSMB->smb_buf_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700306 byte_count += total_in_buf2;
307
308 /* BB also add check that we are not beyond maximum buffer size */
Steve French50c2f752007-07-13 00:33:32 +0000309
Steve French70ca7342005-09-22 16:32:06 -0700310 pTargetSMB->smb_buf_length = byte_count;
Steve Frenche4eb2952005-04-28 22:41:09 -0700311
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000312 if (remaining == total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000313 cFYI(1, ("found the last secondary response"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700314 return 0; /* we are done */
315 } else /* more responses to go */
316 return 1;
317
318}
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320static int
321cifs_demultiplex_thread(struct TCP_Server_Info *server)
322{
323 int length;
324 unsigned int pdu_length, total_read;
325 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700326 struct smb_hdr *bigbuf = NULL;
327 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 struct msghdr smb_msg;
329 struct kvec iov;
330 struct socket *csocket = server->ssocket;
331 struct list_head *tmp;
332 struct cifsSesInfo *ses;
333 struct task_struct *task_to_wake = NULL;
334 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700335 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000336 bool isLargeBuf = false;
337 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700338 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 current->flags |= PF_MEMALLOC;
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700341 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400342
343 length = atomic_inc_return(&tcpSesAllocCount);
344 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000345 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
346 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700348 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000349 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700350 if (try_to_freeze())
351 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700352 if (bigbuf == NULL) {
353 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000354 if (!bigbuf) {
355 cERROR(1, ("No memory for large SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700356 msleep(3000);
357 /* retry will check if exiting */
358 continue;
359 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000360 } else if (isLargeBuf) {
361 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000362 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700364
365 if (smallbuf == NULL) {
366 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000367 if (!smallbuf) {
368 cERROR(1, ("No memory for SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700369 msleep(1000);
370 /* retry will check if exiting */
371 continue;
372 }
373 /* beginning of smb buffer is cleared in our buf_get */
374 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000375 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700376
Steve French4b18f2a2008-04-29 00:06:05 +0000377 isLargeBuf = false;
378 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700379 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 iov.iov_base = smb_buffer;
381 iov.iov_len = 4;
382 smb_msg.msg_control = NULL;
383 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000384 pdu_length = 4; /* enough to get RFC1001 header */
385incomplete_rcv:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 length =
387 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000388 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Jeff Layton469ee612008-10-16 18:46:39 +0000390 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 break;
392 } else if (server->tcpStatus == CifsNeedReconnect) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000393 cFYI(1, ("Reconnect after server stopped responding"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 cifs_reconnect(server);
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000395 cFYI(1, ("call to reconnect done"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 csocket = server->ssocket;
397 continue;
398 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700399 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 allowing socket to clear and app threads to set
401 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000402 if (pdu_length < 4) {
403 iov.iov_base = (4 - pdu_length) +
404 (char *)smb_buffer;
405 iov.iov_len = pdu_length;
406 smb_msg.msg_control = NULL;
407 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000408 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000409 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000410 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 } else if (length <= 0) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000412 if (server->tcpStatus == CifsNew) {
413 cFYI(1, ("tcp session abend after SMBnegprot"));
Steve French09d1db52005-04-28 22:41:08 -0700414 /* some servers kill the TCP session rather than
415 returning an SMB negprot error, in which
416 case reconnecting here is not going to help,
417 and so simply return error to mount */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 break;
419 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000420 if (!try_to_freeze() && (length == -EINTR)) {
Steve French467a8f82007-06-27 22:41:32 +0000421 cFYI(1, ("cifsd thread killed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 break;
423 }
Steve French467a8f82007-06-27 22:41:32 +0000424 cFYI(1, ("Reconnect after unexpected peek error %d",
Steve French57337e42005-04-28 22:41:10 -0700425 length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 cifs_reconnect(server);
427 csocket = server->ssocket;
428 wake_up(&server->response_q);
429 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000430 } else if (length < pdu_length) {
431 cFYI(1, ("requested %d bytes but only got %d bytes",
432 pdu_length, length));
Steve Frenchf01d5e12007-08-30 21:13:31 +0000433 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000434 msleep(1);
435 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 }
Steve French67010fb2005-04-28 22:41:09 -0700437
Steve French70ca7342005-09-22 16:32:06 -0700438 /* The right amount was read from socket - 4 bytes */
439 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700440
Steve French70ca7342005-09-22 16:32:06 -0700441 /* the first byte big endian of the length field,
442 is actually not part of the length but the type
443 with the most common, zero, as regular data */
444 temp = *((char *) smb_buffer);
445
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000446 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700447 but we convert it here so it is always manipulated
448 as host byte order */
Harvey Harrison5ca33c62008-07-23 17:45:58 -0700449 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
Steve French70ca7342005-09-22 16:32:06 -0700450 smb_buffer->smb_buf_length = pdu_length;
Steve French46810cb2005-04-28 22:41:09 -0700451
Steve French467a8f82007-06-27 22:41:32 +0000452 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
Steve French70ca7342005-09-22 16:32:06 -0700453
454 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000455 continue;
Steve French70ca7342005-09-22 16:32:06 -0700456 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Steve French467a8f82007-06-27 22:41:32 +0000457 cFYI(1, ("Good RFC 1002 session rsp"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700458 continue;
Steve French70ca7342005-09-22 16:32:06 -0700459 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000460 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700461 an error on SMB negprot response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000462 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
Steve French70ca7342005-09-22 16:32:06 -0700463 pdu_length));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000464 if (server->tcpStatus == CifsNew) {
465 /* if nack on negprot (rather than
Steve French46810cb2005-04-28 22:41:09 -0700466 ret of smb negprot error) reconnecting
467 not going to help, ret error to mount */
468 break;
469 } else {
470 /* give server a second to
471 clean up before reconnect attempt */
472 msleep(1000);
473 /* always try 445 first on reconnect
474 since we get NACK on some if we ever
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000475 connected to port 139 (the NACK is
Steve French46810cb2005-04-28 22:41:09 -0700476 since we do not begin with RFC1001
477 session initialize frame) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000478 server->addr.sockAddr.sin_port =
Steve French46810cb2005-04-28 22:41:09 -0700479 htons(CIFS_PORT);
480 cifs_reconnect(server);
481 csocket = server->ssocket;
482 wake_up(&server->response_q);
483 continue;
484 }
Steve French70ca7342005-09-22 16:32:06 -0700485 } else if (temp != (char) 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000486 cERROR(1, ("Unknown RFC 1002 frame"));
Steve French70ca7342005-09-22 16:32:06 -0700487 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
488 length);
Steve French46810cb2005-04-28 22:41:09 -0700489 cifs_reconnect(server);
490 csocket = server->ssocket;
491 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700492 }
493
494 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000495 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000496 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700497 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
Steve French46810cb2005-04-28 22:41:09 -0700498 length, pdu_length+4));
Steve Frenche4eb2952005-04-28 22:41:09 -0700499 cifs_reconnect(server);
500 csocket = server->ssocket;
501 wake_up(&server->response_q);
502 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000503 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700504
505 /* else length ok */
506 reconnect = 0;
507
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000508 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000509 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700510 memcpy(bigbuf, smallbuf, 4);
511 smb_buffer = bigbuf;
512 }
513 length = 0;
514 iov.iov_base = 4 + (char *)smb_buffer;
515 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000516 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700517 total_read += length) {
518 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
519 pdu_length - total_read, 0);
Jeff Layton469ee612008-10-16 18:46:39 +0000520 if ((server->tcpStatus == CifsExiting) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700521 (length == -EINTR)) {
522 /* then will exit */
523 reconnect = 2;
524 break;
525 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700526 cifs_reconnect(server);
527 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000528 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700529 /* Now we will reread sock */
530 reconnect = 1;
531 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000532 } else if ((length == -ERESTARTSYS) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700533 (length == -EAGAIN)) {
534 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000535 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700536 threads to set tcpStatus
537 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000538 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700539 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700540 } else if (length <= 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000541 cERROR(1, ("Received no data, expecting %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700542 pdu_length - total_read));
543 cifs_reconnect(server);
544 csocket = server->ssocket;
545 reconnect = 1;
546 break;
Steve French46810cb2005-04-28 22:41:09 -0700547 }
548 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000549 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700550 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000551 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700552 continue;
553
554 length += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000555
Steve Frenche4eb2952005-04-28 22:41:09 -0700556
557 dump_smb(smb_buffer, length);
Steve French184ed212006-02-24 06:15:11 +0000558 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
Steve Frenchb387eae2005-10-10 14:21:15 -0700559 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
Steve Frenche4eb2952005-04-28 22:41:09 -0700560 continue;
561 }
562
563
564 task_to_wake = NULL;
565 spin_lock(&GlobalMid_Lock);
566 list_for_each(tmp, &server->pending_mid_q) {
567 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
568
Steve French50c2f752007-07-13 00:33:32 +0000569 if ((mid_entry->mid == smb_buffer->Mid) &&
Steve Frenche4eb2952005-04-28 22:41:09 -0700570 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
571 (mid_entry->command == smb_buffer->Command)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000572 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700573 /* We have a multipart transact2 resp */
Steve French4b18f2a2008-04-29 00:06:05 +0000574 isMultiRsp = true;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000575 if (mid_entry->resp_buf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700576 /* merge response - fix up 1st*/
Steve French50c2f752007-07-13 00:33:32 +0000577 if (coalesce_t2(smb_buffer,
Steve Frenche4eb2952005-04-28 22:41:09 -0700578 mid_entry->resp_buf)) {
Steve French4b18f2a2008-04-29 00:06:05 +0000579 mid_entry->multiRsp =
580 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700581 break;
582 } else {
583 /* all parts received */
Steve French4b18f2a2008-04-29 00:06:05 +0000584 mid_entry->multiEnd =
585 true;
Steve French50c2f752007-07-13 00:33:32 +0000586 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700587 }
588 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000589 if (!isLargeBuf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700590 cERROR(1,("1st trans2 resp needs bigbuf"));
591 /* BB maybe we can fix this up, switch
Steve French50c2f752007-07-13 00:33:32 +0000592 to already allocated large buffer? */
Steve Frenche4eb2952005-04-28 22:41:09 -0700593 } else {
Steve Frenchcd634992005-04-28 22:41:10 -0700594 /* Have first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700595 mid_entry->resp_buf =
596 smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000597 mid_entry->largeBuf =
598 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700599 bigbuf = NULL;
600 }
601 }
602 break;
Steve French50c2f752007-07-13 00:33:32 +0000603 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700604 mid_entry->resp_buf = smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000605 mid_entry->largeBuf = isLargeBuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700606multi_t2_fnd:
607 task_to_wake = mid_entry->tsk;
608 mid_entry->midState = MID_RESPONSE_RECEIVED;
Steve French1047abc2005-10-11 19:58:06 -0700609#ifdef CONFIG_CIFS_STATS2
610 mid_entry->when_received = jiffies;
611#endif
Steve French3a5ff612006-07-14 22:37:11 +0000612 /* so we do not time out requests to server
613 which is still responding (since server could
614 be busy but not dead) */
615 server->lstrp = jiffies;
Steve Frenche4eb2952005-04-28 22:41:09 -0700616 break;
617 }
618 }
619 spin_unlock(&GlobalMid_Lock);
620 if (task_to_wake) {
Steve Frenchcd634992005-04-28 22:41:10 -0700621 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000622 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700623 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000624 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700625 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000626 else
Steve Frenchcd634992005-04-28 22:41:10 -0700627 smallbuf = NULL;
628 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700629 wake_up_process(task_to_wake);
Steve French4b18f2a2008-04-29 00:06:05 +0000630 } else if (!is_valid_oplock_break(smb_buffer, server) &&
631 !isMultiRsp) {
Steve French50c2f752007-07-13 00:33:32 +0000632 cERROR(1, ("No task to wake, unknown frame received! "
633 "NumMids %d", midCount.counter));
634 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700635 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000636#ifdef CONFIG_CIFS_DEBUG2
637 cifs_dump_detail(smb_buffer);
638 cifs_dump_mids(server);
639#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000640
Steve Frenche4eb2952005-04-28 22:41:09 -0700641 }
642 } /* end while !EXITING */
643
Jeff Laytone7ddee92008-11-14 13:44:38 -0500644 /* take it off the list, if it's not already */
645 write_lock(&cifs_tcp_ses_lock);
646 list_del_init(&server->tcp_ses_list);
647 write_unlock(&cifs_tcp_ses_lock);
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 spin_lock(&GlobalMid_Lock);
650 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000651 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000652 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000653
Steve French31ca3bc2005-04-28 22:41:11 -0700654 /* check if we have blocked requests that need to free */
655 /* Note that cifs_max_pending is normally 50, but
656 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000657 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000658 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700659 atomic_set(&server->inFlight, cifs_max_pending - 1);
660 /* We do not want to set the max_pending too low or we
661 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000663 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700665 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 to the same server - they now will see the session is in exit state
667 and get out of SendReceive. */
668 wake_up_all(&server->request_q);
669 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700670 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000671
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000672 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 sock_release(csocket);
674 server->ssocket = NULL;
675 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700676 /* buffer usuallly freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000677 cifs_buf_release(bigbuf);
678 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700679 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Jeff Layton14fbf502008-11-14 13:53:46 -0500681 /*
682 * BB: we shouldn't have to do any of this. It shouldn't be
683 * possible to exit from the thread with active SMB sessions
684 */
685 read_lock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (list_empty(&server->pending_mid_q)) {
Steve French09d1db52005-04-28 22:41:08 -0700687 /* loop through server session structures attached to this and
688 mark them dead */
Jeff Layton14fbf502008-11-14 13:53:46 -0500689 list_for_each(tmp, &server->smb_ses_list) {
690 ses = list_entry(tmp, struct cifsSesInfo,
691 smb_ses_list);
692 ses->status = CifsExiting;
693 ses->server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500695 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 } else {
Steve French31ca3bc2005-04-28 22:41:11 -0700697 /* although we can not zero the server struct pointer yet,
698 since there are active requests which may depnd on them,
699 mark the corresponding SMB sessions as exiting too */
Jeff Layton14fbf502008-11-14 13:53:46 -0500700 list_for_each(tmp, &server->smb_ses_list) {
Steve French31ca3bc2005-04-28 22:41:11 -0700701 ses = list_entry(tmp, struct cifsSesInfo,
Jeff Layton14fbf502008-11-14 13:53:46 -0500702 smb_ses_list);
703 ses->status = CifsExiting;
Steve French31ca3bc2005-04-28 22:41:11 -0700704 }
705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 spin_lock(&GlobalMid_Lock);
707 list_for_each(tmp, &server->pending_mid_q) {
708 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
709 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French50c2f752007-07-13 00:33:32 +0000710 cFYI(1, ("Clearing Mid 0x%x - waking up ",
711 mid_entry->mid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 task_to_wake = mid_entry->tsk;
Steve French26f57362007-08-30 22:09:15 +0000713 if (task_to_wake)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 wake_up_process(task_to_wake);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 }
716 }
717 spin_unlock(&GlobalMid_Lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500718 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700720 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 }
722
Steve Frenchf1914012005-08-18 09:37:34 -0700723 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000724 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700726 /* due to delays on oplock break requests, we need
727 to wait at least 45 seconds before giving up
728 on a request getting a response and going ahead
729 and killing cifsd */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 cFYI(1, ("Wait for exit from demultiplex thread"));
Steve French31ca3bc2005-04-28 22:41:11 -0700731 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 /* if threads still have not exited they are probably never
733 coming home not much else we can do but free the memory */
734 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Steve French31ca3bc2005-04-28 22:41:11 -0700736 /* last chance to mark ses pointers invalid
737 if there are any pointing to this (e.g
Steve French50c2f752007-07-13 00:33:32 +0000738 if a crazy root user tried to kill cifsd
Steve French31ca3bc2005-04-28 22:41:11 -0700739 kernel thread explicitly this might happen) */
Jeff Layton14fbf502008-11-14 13:53:46 -0500740 /* BB: This shouldn't be necessary, see above */
741 read_lock(&cifs_tcp_ses_lock);
742 list_for_each(tmp, &server->smb_ses_list) {
743 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
744 ses->server = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700745 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500746 read_unlock(&cifs_tcp_ses_lock);
Steve French31ca3bc2005-04-28 22:41:11 -0700747
Jeff Laytonc359cf32007-11-16 22:22:06 +0000748 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400749 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700750 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400751
752 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000753 if (length > 0)
754 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
755 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000756
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400757 /* if server->tsk was NULL then wait for a signal before exiting */
758 if (!task_to_wake) {
759 set_current_state(TASK_INTERRUPTIBLE);
760 while (!signal_pending(current)) {
761 schedule();
762 set_current_state(TASK_INTERRUPTIBLE);
763 }
764 set_current_state(TASK_RUNNING);
765 }
766
Jeff Layton0468a2c2008-12-01 07:09:35 -0500767 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
Jeff Laytonc359cf32007-11-16 22:22:06 +0000770/* extract the host portion of the UNC string */
771static char *
772extract_hostname(const char *unc)
773{
774 const char *src;
775 char *dst, *delim;
776 unsigned int len;
777
778 /* skip double chars at beginning of string */
779 /* BB: check validity of these bytes? */
780 src = unc + 2;
781
782 /* delimiter between hostname and sharename is always '\\' now */
783 delim = strchr(src, '\\');
784 if (!delim)
785 return ERR_PTR(-EINVAL);
786
787 len = delim - src;
788 dst = kmalloc((len + 1), GFP_KERNEL);
789 if (dst == NULL)
790 return ERR_PTR(-ENOMEM);
791
792 memcpy(dst, src, len);
793 dst[len] = '\0';
794
795 return dst;
796}
797
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798static int
Steve French50c2f752007-07-13 00:33:32 +0000799cifs_parse_mount_options(char *options, const char *devname,
800 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
802 char *value;
803 char *data;
804 unsigned int temp_len, i, j;
805 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -0400806 short int override_uid = -1;
807 short int override_gid = -1;
808 bool uid_specified = false;
809 bool gid_specified = false;
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
Linus Torvalds12e36b22006-10-13 08:09:29 -0700814 if (Local_System_Name[0] != 0)
Steve French50c2f752007-07-13 00:33:32 +0000815 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
Steve French2cd646a2006-09-28 19:43:08 +0000816 else {
Linus Torvalds12e36b22006-10-13 08:09:29 -0700817 char *nodename = utsname()->nodename;
Steve French50c2f752007-07-13 00:33:32 +0000818 int n = strnlen(nodename, 15);
819 memset(vol->source_rfc1001_name, 0x20, 15);
820 for (i = 0; i < n; i++) {
Steve French2cd646a2006-09-28 19:43:08 +0000821 /* does not have to be perfect mapping since field is
822 informational, only used for servers that do not support
823 port 445 and it can be overridden at mount time */
Linus Torvalds12e36b22006-10-13 08:09:29 -0700824 vol->source_rfc1001_name[i] = toupper(nodename[i]);
Steve French2cd646a2006-09-28 19:43:08 +0000825 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 }
827 vol->source_rfc1001_name[15] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700828 /* null target name indicates to use *SMBSERVR default called name
829 if we end up sending RFC1001 session initialize */
830 vol->target_rfc1001_name[0] = 0;
David Howellsa001e5b2008-11-14 10:38:47 +1100831 vol->linux_uid = current_uid(); /* use current_euid() instead? */
832 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400833
834 /* default to only allowing write access to owner of the mount */
835 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
837 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -0700838 /* default is always to request posix paths. */
839 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400840 /* default to using server inode numbers where available */
841 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (!options)
844 return 1;
845
Steve French50c2f752007-07-13 00:33:32 +0000846 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000847 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 separator[0] = options[4];
849 options += 5;
850 } else {
Steve French467a8f82007-06-27 22:41:32 +0000851 cFYI(1, ("Null separator not allowed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 }
853 }
Steve French50c2f752007-07-13 00:33:32 +0000854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 while ((data = strsep(&options, separator)) != NULL) {
856 if (!*data)
857 continue;
858 if ((value = strchr(data, '=')) != NULL)
859 *value++ = '\0';
860
Steve French50c2f752007-07-13 00:33:32 +0000861 /* Have to parse this before we parse for "user" */
862 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000864 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 vol->no_xattr = 1;
866 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000867 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 printk(KERN_WARNING
869 "CIFS: invalid or missing username\n");
870 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000871 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000872 /* null user, ie anonymous, authentication */
873 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
875 if (strnlen(value, 200) < 200) {
876 vol->username = value;
877 } else {
878 printk(KERN_WARNING "CIFS: username too long\n");
879 return 1;
880 }
881 } else if (strnicmp(data, "pass", 4) == 0) {
882 if (!value) {
883 vol->password = NULL;
884 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000885 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 /* check if string begins with double comma
887 since that would mean the password really
888 does start with a comma, and would not
889 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000890 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 vol->password = NULL;
892 continue;
893 }
894 }
895 temp_len = strlen(value);
896 /* removed password length check, NTLM passwords
897 can be arbitrarily long */
898
Steve French50c2f752007-07-13 00:33:32 +0000899 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 prematurely null terminated. Commas in password are
901 specified across the cifs mount interface by a double
902 comma ie ,, and a comma used as in other cases ie ','
903 as a parameter delimiter/separator is single and due
904 to the strsep above is temporarily zeroed. */
905
906 /* NB: password legally can have multiple commas and
907 the only illegal character in a password is null */
908
Steve French50c2f752007-07-13 00:33:32 +0000909 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700910 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 /* reinsert comma */
912 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000913 temp_len += 2; /* move after second comma */
914 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000916 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700917 separator[0]) {
918 /* skip second comma */
919 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000920 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 /* single comma indicating start
922 of next parm */
923 break;
924 }
925 }
926 temp_len++;
927 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000928 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 options = NULL;
930 } else {
931 value[temp_len] = 0;
932 /* point option to start of next parm */
933 options = value + temp_len + 1;
934 }
Steve French50c2f752007-07-13 00:33:32 +0000935 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 double commas to singles. Note that this ends up
937 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700938 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000939 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000940 printk(KERN_WARNING "CIFS: no memory "
941 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700942 return 1;
943 }
Steve French50c2f752007-07-13 00:33:32 +0000944 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000946 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700947 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 /* skip second comma */
949 i++;
950 }
951 }
952 vol->password[j] = 0;
953 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700954 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000955 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000956 printk(KERN_WARNING "CIFS: no memory "
957 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700958 return 1;
959 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 strcpy(vol->password, value);
961 }
Jeff Layton58f7f682009-06-10 09:57:55 -0400962 } else if (!strnicmp(data, "ip", 2) ||
963 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (!value || !*value) {
965 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -0400966 } else if (strnlen(value, INET6_ADDRSTRLEN) <
967 INET6_ADDRSTRLEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 vol->UNCip = value;
969 } else {
Steve French50c2f752007-07-13 00:33:32 +0000970 printk(KERN_WARNING "CIFS: ip address "
971 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 return 1;
973 }
Steve French50c2f752007-07-13 00:33:32 +0000974 } else if (strnicmp(data, "sec", 3) == 0) {
975 if (!value || !*value) {
976 cERROR(1, ("no security value specified"));
977 continue;
978 } else if (strnicmp(value, "krb5i", 5) == 0) {
979 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000980 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800981 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000982 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
983 CIFSSEC_MAY_KRB5; */
984 cERROR(1, ("Krb5 cifs privacy not supported"));
Steve Frenchbf820672005-12-01 22:32:42 -0800985 return 1;
986 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000987 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +0000988#ifdef CONFIG_CIFS_EXPERIMENTAL
989 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
990 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
991 CIFSSEC_MUST_SIGN;
992 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
993 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
994#endif
Steve Frenchbf820672005-12-01 22:32:42 -0800995 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000996 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000997 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800998 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000999 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -08001000 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001001 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +00001002 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001003 } else if (strnicmp(value, "ntlm", 4) == 0) {
1004 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001005 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001006 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001007 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001008 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001009#ifdef CONFIG_CIFS_WEAK_PW_HASH
1010 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001011 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001012#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001013 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001014 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001015 } else {
1016 cERROR(1, ("bad security option: %s", value));
1017 return 1;
1018 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 } else if ((strnicmp(data, "unc", 3) == 0)
1020 || (strnicmp(data, "target", 6) == 0)
1021 || (strnicmp(data, "path", 4) == 0)) {
1022 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001023 printk(KERN_WARNING "CIFS: invalid path to "
1024 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 return 1; /* needs_arg; */
1026 }
1027 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001028 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001029 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001031 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 if (strncmp(vol->UNC, "//", 2) == 0) {
1033 vol->UNC[0] = '\\';
1034 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001035 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001037 "CIFS: UNC Path does not begin "
1038 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 return 1;
1040 }
1041 } else {
1042 printk(KERN_WARNING "CIFS: UNC name too long\n");
1043 return 1;
1044 }
1045 } else if ((strnicmp(data, "domain", 3) == 0)
1046 || (strnicmp(data, "workgroup", 5) == 0)) {
1047 if (!value || !*value) {
1048 printk(KERN_WARNING "CIFS: invalid domain name\n");
1049 return 1; /* needs_arg; */
1050 }
1051 /* BB are there cases in which a comma can be valid in
1052 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001053 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 vol->domainname = value;
1055 cFYI(1, ("Domain name set"));
1056 } else {
Steve French50c2f752007-07-13 00:33:32 +00001057 printk(KERN_WARNING "CIFS: domain name too "
1058 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 return 1;
1060 }
Steve French50c2f752007-07-13 00:33:32 +00001061 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1062 if (!value || !*value) {
1063 printk(KERN_WARNING
1064 "CIFS: invalid path prefix\n");
1065 return 1; /* needs_argument */
1066 }
1067 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001068 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001069 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001070 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1071 if (vol->prepath == NULL)
1072 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001073 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001074 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001075 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001076 } else
Steve French50c2f752007-07-13 00:33:32 +00001077 strcpy(vol->prepath, value);
1078 cFYI(1, ("prefix path %s", vol->prepath));
1079 } else {
1080 printk(KERN_WARNING "CIFS: prefix too long\n");
1081 return 1;
1082 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 } else if (strnicmp(data, "iocharset", 9) == 0) {
1084 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001085 printk(KERN_WARNING "CIFS: invalid iocharset "
1086 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 return 1; /* needs_arg; */
1088 }
1089 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001090 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001092 /* if iocharset not set then load_nls_default
1093 is used by caller */
1094 cFYI(1, ("iocharset set to %s", value));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 } else {
Steve French63135e02007-07-17 17:34:02 +00001096 printk(KERN_WARNING "CIFS: iocharset name "
1097 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 return 1;
1099 }
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001100 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1101 vol->linux_uid = simple_strtoul(value, &value, 0);
1102 uid_specified = true;
1103 } else if (!strnicmp(data, "forceuid", 8)) {
1104 override_uid = 1;
1105 } else if (!strnicmp(data, "noforceuid", 10)) {
1106 override_uid = 0;
1107 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1108 vol->linux_gid = simple_strtoul(value, &value, 0);
1109 gid_specified = true;
1110 } else if (!strnicmp(data, "forcegid", 8)) {
1111 override_gid = 1;
1112 } else if (!strnicmp(data, "noforcegid", 10)) {
1113 override_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 } else if (strnicmp(data, "file_mode", 4) == 0) {
1115 if (value && *value) {
1116 vol->file_mode =
1117 simple_strtoul(value, &value, 0);
1118 }
1119 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1120 if (value && *value) {
1121 vol->dir_mode =
1122 simple_strtoul(value, &value, 0);
1123 }
1124 } else if (strnicmp(data, "dirmode", 4) == 0) {
1125 if (value && *value) {
1126 vol->dir_mode =
1127 simple_strtoul(value, &value, 0);
1128 }
1129 } else if (strnicmp(data, "port", 4) == 0) {
1130 if (value && *value) {
1131 vol->port =
1132 simple_strtoul(value, &value, 0);
1133 }
1134 } else if (strnicmp(data, "rsize", 5) == 0) {
1135 if (value && *value) {
1136 vol->rsize =
1137 simple_strtoul(value, &value, 0);
1138 }
1139 } else if (strnicmp(data, "wsize", 5) == 0) {
1140 if (value && *value) {
1141 vol->wsize =
1142 simple_strtoul(value, &value, 0);
1143 }
1144 } else if (strnicmp(data, "sockopt", 5) == 0) {
1145 if (value && *value) {
1146 vol->sockopt =
1147 simple_strtoul(value, &value, 0);
1148 }
1149 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1150 if (!value || !*value || (*value == ' ')) {
Steve French63135e02007-07-17 17:34:02 +00001151 cFYI(1, ("invalid (empty) netbiosname"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 } else {
Steve French50c2f752007-07-13 00:33:32 +00001153 memset(vol->source_rfc1001_name, 0x20, 15);
1154 for (i = 0; i < 15; i++) {
1155 /* BB are there cases in which a comma can be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 valid in this workstation netbios name (and need
1157 special handling)? */
1158
1159 /* We do not uppercase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001160 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 break;
Steve French50c2f752007-07-13 00:33:32 +00001162 else
1163 vol->source_rfc1001_name[i] =
1164 value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 }
1166 /* The string has 16th byte zero still from
1167 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001168 if ((i == 15) && (value[i] != 0))
1169 printk(KERN_WARNING "CIFS: netbiosname"
1170 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001171 }
1172 } else if (strnicmp(data, "servern", 7) == 0) {
1173 /* servernetbiosname specified override *SMBSERVER */
1174 if (!value || !*value || (*value == ' ')) {
Steve French467a8f82007-06-27 22:41:32 +00001175 cFYI(1, ("empty server netbiosname specified"));
Steve Frencha10faeb22005-08-22 21:38:31 -07001176 } else {
1177 /* last byte, type, is 0x20 for servr type */
Steve French50c2f752007-07-13 00:33:32 +00001178 memset(vol->target_rfc1001_name, 0x20, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001179
Steve French50c2f752007-07-13 00:33:32 +00001180 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001181 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001182 valid in this workstation netbios name
1183 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001184
Steve French50c2f752007-07-13 00:33:32 +00001185 /* user or mount helper must uppercase
1186 the netbiosname */
1187 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001188 break;
1189 else
Steve French50c2f752007-07-13 00:33:32 +00001190 vol->target_rfc1001_name[i] =
1191 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001192 }
1193 /* The string has 16th byte zero still from
1194 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001195 if ((i == 15) && (value[i] != 0))
1196 printk(KERN_WARNING "CIFS: server net"
1197 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 }
1199 } else if (strnicmp(data, "credentials", 4) == 0) {
1200 /* ignore */
1201 } else if (strnicmp(data, "version", 3) == 0) {
1202 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001203 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 /* ignore */
Steve French71a394f2009-06-26 04:07:18 +00001205 } else if (strnicmp(data, "rw", 2) == 0) {
1206 /* ignore */
1207 } else if (strnicmp(data, "ro", 2) == 0) {
1208 /* ignore */
Steve Frenchedf1ae42008-10-29 00:47:57 +00001209 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1210 vol->noblocksnd = 1;
1211 } else if (strnicmp(data, "noautotune", 10) == 0) {
1212 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 } else if ((strnicmp(data, "suid", 4) == 0) ||
1214 (strnicmp(data, "nosuid", 6) == 0) ||
1215 (strnicmp(data, "exec", 4) == 0) ||
1216 (strnicmp(data, "noexec", 6) == 0) ||
1217 (strnicmp(data, "nodev", 5) == 0) ||
1218 (strnicmp(data, "noauto", 6) == 0) ||
1219 (strnicmp(data, "dev", 3) == 0)) {
1220 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001221 uses these opts to set flags, and the flags are read
1222 by the kernel vfs layer before we get here (ie
1223 before read super) so there is no point trying to
1224 parse these options again and set anything and it
1225 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 } else if (strnicmp(data, "hard", 4) == 0) {
1228 vol->retry = 1;
1229 } else if (strnicmp(data, "soft", 4) == 0) {
1230 vol->retry = 0;
1231 } else if (strnicmp(data, "perm", 4) == 0) {
1232 vol->noperm = 0;
1233 } else if (strnicmp(data, "noperm", 6) == 0) {
1234 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001235 } else if (strnicmp(data, "mapchars", 8) == 0) {
1236 vol->remap = 1;
1237 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1238 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001239 } else if (strnicmp(data, "sfu", 3) == 0) {
1240 vol->sfu_emul = 1;
1241 } else if (strnicmp(data, "nosfu", 5) == 0) {
1242 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001243 } else if (strnicmp(data, "nodfs", 5) == 0) {
1244 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001245 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1246 vol->posix_paths = 1;
1247 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1248 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001249 } else if (strnicmp(data, "nounix", 6) == 0) {
1250 vol->no_linux_ext = 1;
1251 } else if (strnicmp(data, "nolinux", 7) == 0) {
1252 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001253 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001254 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001255 vol->nocase = 1;
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001256 } else if (strnicmp(data, "brl", 3) == 0) {
1257 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001258 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001259 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001260 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001261 /* turn off mandatory locking in mode
1262 if remote locking is turned off since the
1263 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001264 if (vol->file_mode ==
1265 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001266 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001267 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1268 /* will take the shorter form "forcemand" as well */
1269 /* This mount option will force use of mandatory
1270 (DOS/Windows style) byte range locks, instead of
1271 using posix advisory byte range locks, even if the
1272 Unix extensions are available and posix locks would
1273 be supported otherwise. If Unix extensions are not
1274 negotiated this has no effect since mandatory locks
1275 would be used (mandatory locks is all that those
1276 those servers support) */
1277 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 } else if (strnicmp(data, "setuids", 7) == 0) {
1279 vol->setuids = 1;
1280 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1281 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001282 } else if (strnicmp(data, "dynperm", 7) == 0) {
1283 vol->dynperm = true;
1284 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1285 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 } else if (strnicmp(data, "nohard", 6) == 0) {
1287 vol->retry = 0;
1288 } else if (strnicmp(data, "nosoft", 6) == 0) {
1289 vol->retry = 1;
1290 } else if (strnicmp(data, "nointr", 6) == 0) {
1291 vol->intr = 0;
1292 } else if (strnicmp(data, "intr", 4) == 0) {
1293 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001294 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1295 vol->nostrictsync = 1;
1296 } else if (strnicmp(data, "strictsync", 10) == 0) {
1297 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001298 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001300 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001302 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001303 vol->cifs_acl = 1;
1304 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1305 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001306 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001308 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001310#ifdef CONFIG_CIFS_EXPERIMENTAL
1311 } else if (strnicmp(data, "locallease", 6) == 0) {
1312 vol->local_lease = 1;
1313#endif
Steve French50c2f752007-07-13 00:33:32 +00001314 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001315 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001316 } else if (strnicmp(data, "seal", 4) == 0) {
1317 /* we do not do the following in secFlags because seal
1318 is a per tree connection (mount) not a per socket
1319 or per-smb connection option in the protocol */
1320 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1321 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001322 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001324 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 vol->direct_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001327 printk(KERN_WARNING "CIFS: Mount option noac not "
1328 "supported. Instead set "
1329 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 } else
Steve French50c2f752007-07-13 00:33:32 +00001331 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1332 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
1334 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001335 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001336 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1337 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 return 1;
1339 }
1340 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001341 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001342 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001344 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 if (strncmp(vol->UNC, "//", 2) == 0) {
1346 vol->UNC[0] = '\\';
1347 vol->UNC[1] = '\\';
1348 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001349 printk(KERN_WARNING "CIFS: UNC Path does not "
1350 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 return 1;
1352 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001353 value = strpbrk(vol->UNC+2, "/\\");
1354 if (value)
1355 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 } else {
1357 printk(KERN_WARNING "CIFS: UNC name too long\n");
1358 return 1;
1359 }
1360 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001361 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 vol->UNCip = &vol->UNC[2];
1363
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001364 if (uid_specified)
1365 vol->override_uid = override_uid;
1366 else if (override_uid == 1)
1367 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1368 "specified with no uid= option.\n");
1369
1370 if (gid_specified)
1371 vol->override_gid = override_gid;
1372 else if (override_gid == 1)
1373 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1374 "specified with no gid= option.\n");
1375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 return 0;
1377}
1378
Jeff Laytone7ddee92008-11-14 13:44:38 -05001379static struct TCP_Server_Info *
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301380cifs_find_tcp_session(struct sockaddr_storage *addr, unsigned short int port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
1382 struct list_head *tmp;
Jeff Laytone7ddee92008-11-14 13:44:38 -05001383 struct TCP_Server_Info *server;
1384 struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1385 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Jeff Laytone7ddee92008-11-14 13:44:38 -05001387 write_lock(&cifs_tcp_ses_lock);
1388 list_for_each(tmp, &cifs_tcp_ses_list) {
1389 server = list_entry(tmp, struct TCP_Server_Info,
1390 tcp_ses_list);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001391 /*
1392 * the demux thread can exit on its own while still in CifsNew
1393 * so don't accept any sockets in that state. Since the
1394 * tcpStatus never changes back to CifsNew it's safe to check
1395 * for this without a lock.
1396 */
1397 if (server->tcpStatus == CifsNew)
Cyrill Gorcunov1b20d672008-05-09 18:17:21 +00001398 continue;
Steve French50c2f752007-07-13 00:33:32 +00001399
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301400 switch (addr->ss_family) {
1401 case AF_INET:
1402 if (addr4->sin_addr.s_addr ==
1403 server->addr.sockAddr.sin_addr.s_addr) {
1404 addr4->sin_port = htons(port);
1405 /* user overrode default port? */
1406 if (addr4->sin_port) {
1407 if (addr4->sin_port !=
1408 server->addr.sockAddr.sin_port)
1409 continue;
1410 }
1411 break;
1412 } else
1413 continue;
1414
1415 case AF_INET6:
1416 if (ipv6_addr_equal(&addr6->sin6_addr,
1417 &server->addr.sockAddr6.sin6_addr) &&
Steve Frenchca43e3b2009-09-01 17:20:50 +00001418 (addr6->sin6_scope_id ==
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301419 server->addr.sockAddr6.sin6_scope_id)) {
1420 addr6->sin6_port = htons(port);
1421 /* user overrode default port? */
1422 if (addr6->sin6_port) {
Steve Frenchca43e3b2009-09-01 17:20:50 +00001423 if (addr6->sin6_port !=
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301424 server->addr.sockAddr6.sin6_port)
Steve Frenchca43e3b2009-09-01 17:20:50 +00001425 continue;
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301426 }
1427 break;
Steve Frenchca43e3b2009-09-01 17:20:50 +00001428 } else
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301429 continue;
1430 }
Steve French50c2f752007-07-13 00:33:32 +00001431
Jeff Laytone7ddee92008-11-14 13:44:38 -05001432 ++server->srv_count;
1433 write_unlock(&cifs_tcp_ses_lock);
Steve Frenchd82c2df2008-11-15 00:07:26 +00001434 cFYI(1, ("Existing tcp session with server found"));
Jeff Laytone7ddee92008-11-14 13:44:38 -05001435 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 }
Jeff Laytone7ddee92008-11-14 13:44:38 -05001437 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 return NULL;
1439}
1440
Jeff Layton14fbf502008-11-14 13:53:46 -05001441static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001442cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001444 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
Jeff Laytone7ddee92008-11-14 13:44:38 -05001446 write_lock(&cifs_tcp_ses_lock);
1447 if (--server->srv_count > 0) {
1448 write_unlock(&cifs_tcp_ses_lock);
1449 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001451
Jeff Laytone7ddee92008-11-14 13:44:38 -05001452 list_del_init(&server->tcp_ses_list);
1453 write_unlock(&cifs_tcp_ses_lock);
1454
1455 spin_lock(&GlobalMid_Lock);
1456 server->tcpStatus = CifsExiting;
1457 spin_unlock(&GlobalMid_Lock);
1458
1459 task = xchg(&server->tsk, NULL);
1460 if (task)
1461 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462}
1463
Jeff Layton63c038c2008-12-01 18:41:46 -05001464static struct TCP_Server_Info *
1465cifs_get_tcp_session(struct smb_vol *volume_info)
1466{
1467 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001468 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001469 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1470 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1471 int rc;
1472
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001473 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001474
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001475 cFYI(1, ("UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip));
1476
Jeff Layton63c038c2008-12-01 18:41:46 -05001477 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001478 rc = cifs_convert_address(volume_info->UNCip, &addr);
1479 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001480 /* we failed translating address */
1481 rc = -EINVAL;
1482 goto out_err;
1483 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001484 } else if (volume_info->UNCip) {
1485 /* BB using ip addr as tcp_ses name to connect to the
1486 DFS root below */
1487 cERROR(1, ("Connecting to DFS root not implemented yet"));
1488 rc = -EINVAL;
1489 goto out_err;
1490 } else /* which tcp_sess DFS root would we conect to */ {
1491 cERROR(1,
1492 ("CIFS mount error: No UNC path (e.g. -o "
1493 "unc=//192.168.1.100/public) specified"));
1494 rc = -EINVAL;
1495 goto out_err;
1496 }
1497
1498 /* see if we already have a matching tcp_ses */
Suresh Jayaramanbdb97ad2009-08-20 13:03:34 +05301499 tcp_ses = cifs_find_tcp_session(&addr, volume_info->port);
Jeff Layton63c038c2008-12-01 18:41:46 -05001500 if (tcp_ses)
1501 return tcp_ses;
1502
1503 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1504 if (!tcp_ses) {
1505 rc = -ENOMEM;
1506 goto out_err;
1507 }
1508
1509 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1510 if (IS_ERR(tcp_ses->hostname)) {
1511 rc = PTR_ERR(tcp_ses->hostname);
1512 goto out_err;
1513 }
1514
1515 tcp_ses->noblocksnd = volume_info->noblocksnd;
1516 tcp_ses->noautotune = volume_info->noautotune;
1517 atomic_set(&tcp_ses->inFlight, 0);
1518 init_waitqueue_head(&tcp_ses->response_q);
1519 init_waitqueue_head(&tcp_ses->request_q);
1520 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1521 mutex_init(&tcp_ses->srv_mutex);
1522 memcpy(tcp_ses->workstation_RFC1001_name,
1523 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1524 memcpy(tcp_ses->server_RFC1001_name,
1525 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1526 tcp_ses->sequence_number = 0;
1527 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1528 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1529
1530 /*
1531 * at this point we are the only ones with the pointer
1532 * to the struct since the kernel thread not created yet
1533 * no need to spinlock this init of tcpStatus or srv_count
1534 */
1535 tcp_ses->tcpStatus = CifsNew;
1536 ++tcp_ses->srv_count;
1537
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001538 if (addr.ss_family == AF_INET6) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001539 cFYI(1, ("attempting ipv6 connect"));
1540 /* BB should we allow ipv6 on port 139? */
1541 /* other OS never observed in Wild doing 139 with v6 */
Simo Leone6debdbc2009-06-25 02:44:43 +00001542 sin_server6->sin6_port = htons(volume_info->port);
Jeff Layton63c038c2008-12-01 18:41:46 -05001543 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1544 sizeof(struct sockaddr_in6));
Jeff Laytond5c56052008-12-01 18:42:33 -05001545 rc = ipv6_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001546 } else {
Simo Leone6debdbc2009-06-25 02:44:43 +00001547 sin_server->sin_port = htons(volume_info->port);
Jeff Layton63c038c2008-12-01 18:41:46 -05001548 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1549 sizeof(struct sockaddr_in));
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001550 rc = ipv4_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001551 }
1552 if (rc < 0) {
1553 cERROR(1, ("Error connecting to socket. Aborting operation"));
1554 goto out_err;
1555 }
1556
1557 /*
1558 * since we're in a cifs function already, we know that
1559 * this will succeed. No need for try_module_get().
1560 */
1561 __module_get(THIS_MODULE);
1562 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1563 tcp_ses, "cifsd");
1564 if (IS_ERR(tcp_ses->tsk)) {
1565 rc = PTR_ERR(tcp_ses->tsk);
1566 cERROR(1, ("error %d create cifsd thread", rc));
1567 module_put(THIS_MODULE);
1568 goto out_err;
1569 }
1570
1571 /* thread spawned, put it on the list */
1572 write_lock(&cifs_tcp_ses_lock);
1573 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1574 write_unlock(&cifs_tcp_ses_lock);
1575
1576 return tcp_ses;
1577
1578out_err:
1579 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00001580 if (!IS_ERR(tcp_ses->hostname))
1581 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05001582 if (tcp_ses->ssocket)
1583 sock_release(tcp_ses->ssocket);
1584 kfree(tcp_ses);
1585 }
1586 return ERR_PTR(rc);
1587}
1588
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589static struct cifsSesInfo *
Jeff Layton14fbf502008-11-14 13:53:46 -05001590cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591{
1592 struct list_head *tmp;
1593 struct cifsSesInfo *ses;
1594
Jeff Layton14fbf502008-11-14 13:53:46 -05001595 write_lock(&cifs_tcp_ses_lock);
1596 list_for_each(tmp, &server->smb_ses_list) {
1597 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1598 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 continue;
1600
Jeff Layton14fbf502008-11-14 13:53:46 -05001601 ++ses->ses_count;
1602 write_unlock(&cifs_tcp_ses_lock);
1603 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001605 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 return NULL;
1607}
1608
Jeff Layton14fbf502008-11-14 13:53:46 -05001609static void
1610cifs_put_smb_ses(struct cifsSesInfo *ses)
1611{
1612 int xid;
1613 struct TCP_Server_Info *server = ses->server;
1614
1615 write_lock(&cifs_tcp_ses_lock);
1616 if (--ses->ses_count > 0) {
1617 write_unlock(&cifs_tcp_ses_lock);
1618 return;
1619 }
1620
1621 list_del_init(&ses->smb_ses_list);
1622 write_unlock(&cifs_tcp_ses_lock);
1623
1624 if (ses->status == CifsGood) {
1625 xid = GetXid();
1626 CIFSSMBLogoff(xid, ses);
1627 _FreeXid(xid);
1628 }
1629 sesInfoFree(ses);
1630 cifs_put_tcp_session(server);
1631}
1632
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05001634cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635{
1636 struct list_head *tmp;
1637 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Jeff Laytonf1987b42008-11-15 11:12:47 -05001639 write_lock(&cifs_tcp_ses_lock);
1640 list_for_each(tmp, &ses->tcon_list) {
1641 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1642 if (tcon->tidStatus == CifsExiting)
1643 continue;
1644 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 continue;
1646
Jeff Laytonf1987b42008-11-15 11:12:47 -05001647 ++tcon->tc_count;
1648 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 return tcon;
1650 }
Jeff Laytonf1987b42008-11-15 11:12:47 -05001651 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 return NULL;
1653}
1654
Jeff Laytonf1987b42008-11-15 11:12:47 -05001655static void
1656cifs_put_tcon(struct cifsTconInfo *tcon)
1657{
1658 int xid;
1659 struct cifsSesInfo *ses = tcon->ses;
1660
1661 write_lock(&cifs_tcp_ses_lock);
1662 if (--tcon->tc_count > 0) {
1663 write_unlock(&cifs_tcp_ses_lock);
1664 return;
1665 }
1666
1667 list_del_init(&tcon->tcon_list);
1668 write_unlock(&cifs_tcp_ses_lock);
1669
1670 xid = GetXid();
1671 CIFSSMBTDis(xid, tcon);
1672 _FreeXid(xid);
1673
Jeff Laytonf1987b42008-11-15 11:12:47 -05001674 tconInfoFree(tcon);
1675 cifs_put_smb_ses(ses);
1676}
1677
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678int
Steve French50c2f752007-07-13 00:33:32 +00001679get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1680 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00001681 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682{
1683 char *temp_unc;
1684 int rc = 0;
1685
1686 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00001687 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
1689 if (pSesInfo->ipc_tid == 0) {
1690 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00001691 strnlen(pSesInfo->serverName,
1692 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 + 1 + 4 /* slash IPC$ */ + 2,
1694 GFP_KERNEL);
1695 if (temp_unc == NULL)
1696 return -ENOMEM;
1697 temp_unc[0] = '\\';
1698 temp_unc[1] = '\\';
1699 strcpy(temp_unc + 2, pSesInfo->serverName);
1700 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1701 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1702 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00001703 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 kfree(temp_unc);
1705 }
1706 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00001707 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07001708 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00001709 /* BB map targetUNCs to dfs_info3 structures, here or
1710 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711
1712 return rc;
1713}
1714
Jeff Layton09e50d52008-07-23 10:11:19 -04001715#ifdef CONFIG_DEBUG_LOCK_ALLOC
1716static struct lock_class_key cifs_key[2];
1717static struct lock_class_key cifs_slock_key[2];
1718
1719static inline void
1720cifs_reclassify_socket4(struct socket *sock)
1721{
1722 struct sock *sk = sock->sk;
1723 BUG_ON(sock_owned_by_user(sk));
1724 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1725 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1726}
1727
1728static inline void
1729cifs_reclassify_socket6(struct socket *sock)
1730{
1731 struct sock *sk = sock->sk;
1732 BUG_ON(sock_owned_by_user(sk));
1733 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1734 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1735}
1736#else
1737static inline void
1738cifs_reclassify_socket4(struct socket *sock)
1739{
1740}
1741
1742static inline void
1743cifs_reclassify_socket6(struct socket *sock)
1744{
1745}
1746#endif
1747
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00001749static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750{
Steve French50c2f752007-07-13 00:33:32 +00001751 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
Steve French50c2f752007-07-13 00:33:32 +00001753 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 /* mask a nibble at a time and encode */
1755 target[j] = 'A' + (0x0F & (source[i] >> 4));
1756 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00001757 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 }
1759
1760}
1761
1762
1763static int
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001764ipv4_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765{
1766 int rc = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001767 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 __be16 orig_port = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001769 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001771 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001772 rc = sock_create_kern(PF_INET, SOCK_STREAM,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001773 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001775 cERROR(1, ("Error %d creating socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001778
1779 /* BB other socket options to set KEEPALIVE, NODELAY? */
1780 cFYI(1, ("Socket created"));
1781 server->ssocket = socket;
1782 socket->sk->sk_allocation = GFP_NOFS;
1783 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 }
1785
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001786 /* user overrode default port */
1787 if (server->addr.sockAddr.sin_port) {
1788 rc = socket->ops->connect(socket, (struct sockaddr *)
1789 &server->addr.sockAddr,
1790 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001792 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001795 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001796 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 later if fall back ports fail this time */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001798 orig_port = server->addr.sockAddr.sin_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
1800 /* do not retry on the same port we just failed on */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001801 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
1802 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
1803 rc = socket->ops->connect(socket,
1804 (struct sockaddr *)
1805 &server->addr.sockAddr,
1806 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001808 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 }
1810 }
1811 if (!connected) {
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001812 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
1813 rc = socket->ops->connect(socket, (struct sockaddr *)
1814 &server->addr.sockAddr,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001815 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00001816 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001817 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 }
1819
1820 /* give up here - unless we want to retry on different
1821 protocol families some day */
1822 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001823 if (orig_port)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001824 server->addr.sockAddr.sin_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001825 cFYI(1, ("Error %d connecting to server via ipv4", rc));
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001826 sock_release(socket);
1827 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 return rc;
1829 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001830
1831
1832 /*
1833 * Eventually check for other socket options to change from
1834 * the default. sock_setsockopt not used because it expects
1835 * user space buffer
1836 */
1837 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001838 socket->sk->sk_sndtimeo = 5 * HZ;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001839
Steve Frenchb387eae2005-10-10 14:21:15 -07001840 /* make the bufsizes depend on wsize/rsize and max requests */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001841 if (server->noautotune) {
1842 if (socket->sk->sk_sndbuf < (200 * 1024))
1843 socket->sk->sk_sndbuf = 200 * 1024;
1844 if (socket->sk->sk_rcvbuf < (140 * 1024))
1845 socket->sk->sk_rcvbuf = 140 * 1024;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001846 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001848 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1849 socket->sk->sk_sndbuf,
1850 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo));
1851
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 /* send RFC1001 sessinit */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001853 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00001855 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00001857 struct rfc1002_session_packet *ses_init_buf;
1858 struct smb_hdr *smb_buf;
1859 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1860 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001861 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 ses_init_buf->trailer.session_req.called_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001863 if (server->server_RFC1001_name &&
1864 server->server_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001865 rfc1002mangle(ses_init_buf->trailer.
1866 session_req.called_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001867 server->server_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001868 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001869 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001870 rfc1002mangle(ses_init_buf->trailer.
1871 session_req.called_name,
1872 DEFAULT_CIFS_CALLED_NAME,
1873 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001874
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 ses_init_buf->trailer.session_req.calling_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001876
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 /* calling name ends in null (byte 16) from old smb
1878 convention. */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001879 if (server->workstation_RFC1001_name &&
1880 server->workstation_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001881 rfc1002mangle(ses_init_buf->trailer.
1882 session_req.calling_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001883 server->workstation_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001884 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001885 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001886 rfc1002mangle(ses_init_buf->trailer.
1887 session_req.calling_name,
1888 "LINUX_CIFS_CLNT",
1889 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001890
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 ses_init_buf->trailer.session_req.scope1 = 0;
1892 ses_init_buf->trailer.session_req.scope2 = 0;
1893 smb_buf = (struct smb_hdr *)ses_init_buf;
1894 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1895 smb_buf->smb_buf_length = 0x81000044;
Jeff Layton0496e022008-12-30 12:39:16 -05001896 rc = smb_send(server, smb_buf, 0x44);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00001898 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00001899 requires very short break before negprot
1900 presumably because not expecting negprot
1901 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00001902 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00001903 complicating the code and causes no
1904 significant slowing down on mount
1905 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 }
Steve French50c2f752007-07-13 00:33:32 +00001907 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00001909
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 }
Steve French50c2f752007-07-13 00:33:32 +00001911
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 return rc;
1913}
1914
1915static int
Jeff Laytond5c56052008-12-01 18:42:33 -05001916ipv6_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917{
1918 int rc = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001919 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 __be16 orig_port = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001921 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
Jeff Laytond5c56052008-12-01 18:42:33 -05001923 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001924 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
Jeff Laytond5c56052008-12-01 18:42:33 -05001925 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001927 cERROR(1, ("Error %d creating ipv6 socket", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001928 socket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 }
Jeff Laytond5c56052008-12-01 18:42:33 -05001931
1932 /* BB other socket options to set KEEPALIVE, NODELAY? */
1933 cFYI(1, ("ipv6 Socket created"));
1934 server->ssocket = socket;
1935 socket->sk->sk_allocation = GFP_NOFS;
1936 cifs_reclassify_socket6(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 }
1938
Jeff Laytond5c56052008-12-01 18:42:33 -05001939 /* user overrode default port */
1940 if (server->addr.sockAddr6.sin6_port) {
1941 rc = socket->ops->connect(socket,
1942 (struct sockaddr *) &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001943 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001945 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001946 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001948 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001949 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 later if fall back ports fail this time */
1951
Jeff Laytond5c56052008-12-01 18:42:33 -05001952 orig_port = server->addr.sockAddr6.sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 /* do not retry on the same port we just failed on */
Jeff Laytond5c56052008-12-01 18:42:33 -05001954 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
1955 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
1956 rc = socket->ops->connect(socket, (struct sockaddr *)
1957 &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001958 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001960 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 }
1962 }
1963 if (!connected) {
Jeff Laytond5c56052008-12-01 18:42:33 -05001964 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
1965 rc = socket->ops->connect(socket, (struct sockaddr *)
1966 &server->addr.sockAddr6,
1967 sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00001968 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001969 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 }
1971
1972 /* give up here - unless we want to retry on different
1973 protocol families some day */
1974 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001975 if (orig_port)
Jeff Laytond5c56052008-12-01 18:42:33 -05001976 server->addr.sockAddr6.sin6_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001977 cFYI(1, ("Error %d connecting to server via ipv6", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001978 sock_release(socket);
1979 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980 return rc;
1981 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00001982
Jeff Laytond5c56052008-12-01 18:42:33 -05001983 /*
1984 * Eventually check for other socket options to change from
1985 * the default. sock_setsockopt not used because it expects
1986 * user space buffer
1987 */
1988 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001989 socket->sk->sk_sndtimeo = 5 * HZ;
Jeff Laytond5c56052008-12-01 18:42:33 -05001990 server->ssocket = socket;
Steve French50c2f752007-07-13 00:33:32 +00001991
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 return rc;
1993}
1994
Steve French50c2f752007-07-13 00:33:32 +00001995void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1996 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00001997{
1998 /* if we are reconnecting then should we check to see if
1999 * any requested capabilities changed locally e.g. via
2000 * remount but we can not do much about it here
2001 * if they have (even if we could detect it by the following)
2002 * Perhaps we could add a backpointer to array of sb from tcon
2003 * or if we change to make all sb to same share the same
2004 * sb as NFS - then we only have one backpointer to sb.
2005 * What if we wanted to mount the server share twice once with
2006 * and once without posixacls or posix paths? */
2007 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002008
Steve Frenchc18c8422007-07-18 23:21:09 +00002009 if (vol_info && vol_info->no_linux_ext) {
2010 tcon->fsUnixInfo.Capability = 0;
2011 tcon->unix_ext = 0; /* Unix Extensions disabled */
2012 cFYI(1, ("Linux protocol extensions disabled"));
2013 return;
2014 } else if (vol_info)
2015 tcon->unix_ext = 1; /* Unix Extensions supported */
2016
2017 if (tcon->unix_ext == 0) {
2018 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
2019 return;
2020 }
Steve French50c2f752007-07-13 00:33:32 +00002021
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002022 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00002023 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002024
Steve French8af18972007-02-14 04:42:51 +00002025 /* check for reconnect case in which we do not
2026 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002027 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002028 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002029 originally at mount time */
2030 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2031 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002032 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2033 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2034 cERROR(1, ("POSIXPATH support change"));
Steve French8af18972007-02-14 04:42:51 +00002035 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002036 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2037 cERROR(1, ("possible reconnect error"));
2038 cERROR(1,
2039 ("server disabled POSIX path support"));
2040 }
Steve French8af18972007-02-14 04:42:51 +00002041 }
Steve French50c2f752007-07-13 00:33:32 +00002042
Steve French8af18972007-02-14 04:42:51 +00002043 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002044 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002045 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002046 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002047 cFYI(1, ("negotiated posix acl support"));
2048 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002049 sb->s_flags |= MS_POSIXACL;
2050 }
2051
Steve French75865f8c2007-06-24 18:30:48 +00002052 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002053 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002054 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002055 cFYI(1, ("negotiate posix pathnames"));
Steve French75865f8c2007-06-24 18:30:48 +00002056 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002057 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002058 CIFS_MOUNT_POSIX_PATHS;
2059 }
Steve French50c2f752007-07-13 00:33:32 +00002060
Steve French984acfe2007-04-26 16:42:50 +00002061 /* We might be setting the path sep back to a different
2062 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002063 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002064 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002065 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002066
2067 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2068 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2069 CIFS_SB(sb)->rsize = 127 * 1024;
Steve French90c81e02008-02-12 20:32:36 +00002070 cFYI(DBG2,
2071 ("larger reads not supported by srv"));
Steve French75865f8c2007-06-24 18:30:48 +00002072 }
2073 }
Steve French50c2f752007-07-13 00:33:32 +00002074
2075
2076 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
Steve French8af18972007-02-14 04:42:51 +00002077#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002078 if (cap & CIFS_UNIX_FCNTL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002079 cFYI(1, ("FCNTL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002080 if (cap & CIFS_UNIX_EXTATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002081 cFYI(1, ("EXTATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002082 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002083 cFYI(1, ("POSIX path cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002084 if (cap & CIFS_UNIX_XATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002085 cFYI(1, ("XATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002086 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002087 cFYI(1, ("POSIX ACL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002088 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002089 cFYI(1, ("very large read cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002090 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002091 cFYI(1, ("very large write cap"));
Steve French8af18972007-02-14 04:42:51 +00002092#endif /* CIFS_DEBUG2 */
2093 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002094 if (vol_info == NULL) {
Steve French5a44b312007-09-20 15:16:24 +00002095 cFYI(1, ("resetting capabilities failed"));
Steve French442aa312007-09-24 20:25:46 +00002096 } else
Steve French5a44b312007-09-20 15:16:24 +00002097 cERROR(1, ("Negotiating Unix capabilities "
2098 "with the server failed. Consider "
2099 "mounting with the Unix Extensions\n"
2100 "disabled, if problems are found, "
2101 "by specifying the nounix mount "
Steve French2224f4e2007-09-20 15:37:29 +00002102 "option."));
Steve French5a44b312007-09-20 15:16:24 +00002103
Steve French8af18972007-02-14 04:42:51 +00002104 }
2105 }
2106}
2107
Steve French03a143c2008-02-14 06:38:30 +00002108static void
2109convert_delimiter(char *path, char delim)
2110{
2111 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002112 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002113
2114 if (path == NULL)
2115 return;
2116
Steve French582d21e2008-05-13 04:54:12 +00002117 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002118 old_delim = '\\';
2119 else
2120 old_delim = '/';
2121
Steve French03a143c2008-02-14 06:38:30 +00002122 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002123 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002124 path[i] = delim;
2125 }
2126}
2127
Steve French3b795212008-11-13 19:45:32 +00002128static void setup_cifs_sb(struct smb_vol *pvolume_info,
2129 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002130{
Steve French3b795212008-11-13 19:45:32 +00002131 if (pvolume_info->rsize > CIFSMaxBufSize) {
2132 cERROR(1, ("rsize %d too large, using MaxBufSize",
2133 pvolume_info->rsize));
2134 cifs_sb->rsize = CIFSMaxBufSize;
2135 } else if ((pvolume_info->rsize) &&
2136 (pvolume_info->rsize <= CIFSMaxBufSize))
2137 cifs_sb->rsize = pvolume_info->rsize;
2138 else /* default */
2139 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002140
Steve French3b795212008-11-13 19:45:32 +00002141 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2142 cERROR(1, ("wsize %d too large, using 4096 instead",
2143 pvolume_info->wsize));
2144 cifs_sb->wsize = 4096;
2145 } else if (pvolume_info->wsize)
2146 cifs_sb->wsize = pvolume_info->wsize;
2147 else
2148 cifs_sb->wsize = min_t(const int,
2149 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2150 127*1024);
2151 /* old default of CIFSMaxBufSize was too small now
2152 that SMB Write2 can send multiple pages in kvec.
2153 RFC1001 does not describe what happens when frame
2154 bigger than 128K is sent so use that as max in
2155 conjunction with 52K kvec constraint on arch with 4K
2156 page size */
2157
2158 if (cifs_sb->rsize < 2048) {
2159 cifs_sb->rsize = 2048;
2160 /* Windows ME may prefer this */
2161 cFYI(1, ("readsize set to minimum: 2048"));
2162 }
2163 /* calculate prepath */
2164 cifs_sb->prepath = pvolume_info->prepath;
2165 if (cifs_sb->prepath) {
2166 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2167 /* we can not convert the / to \ in the path
2168 separators in the prefixpath yet because we do not
2169 know (until reset_cifs_unix_caps is called later)
2170 whether POSIX PATH CAP is available. We normalize
2171 the / to \ after reset_cifs_unix_caps is called */
2172 pvolume_info->prepath = NULL;
2173 } else
2174 cifs_sb->prepathlen = 0;
2175 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2176 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2177 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2178 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2179 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2180 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2181
2182 if (pvolume_info->noperm)
2183 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2184 if (pvolume_info->setuids)
2185 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2186 if (pvolume_info->server_ino)
2187 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2188 if (pvolume_info->remap)
2189 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2190 if (pvolume_info->no_xattr)
2191 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2192 if (pvolume_info->sfu_emul)
2193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2194 if (pvolume_info->nobrl)
2195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002196 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002198 if (pvolume_info->mand_lock)
2199 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002200 if (pvolume_info->cifs_acl)
2201 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2202 if (pvolume_info->override_uid)
2203 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2204 if (pvolume_info->override_gid)
2205 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2206 if (pvolume_info->dynperm)
2207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2208 if (pvolume_info->direct_io) {
2209 cFYI(1, ("mounting share using direct i/o"));
2210 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2211 }
2212
2213 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2214 cERROR(1, ("mount option dynperm ignored if cifsacl "
2215 "mount option supported"));
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002216}
2217
Igor Mammedove4cce942009-02-10 14:10:26 +03002218static int
2219is_path_accessible(int xid, struct cifsTconInfo *tcon,
2220 struct cifs_sb_info *cifs_sb, const char *full_path)
2221{
2222 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03002223 FILE_ALL_INFO *pfile_info;
2224
Igor Mammedove4cce942009-02-10 14:10:26 +03002225 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2226 if (pfile_info == NULL)
2227 return -ENOMEM;
2228
2229 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2230 0 /* not legacy */, cifs_sb->local_nls,
2231 cifs_sb->mnt_cifs_flags &
2232 CIFS_MOUNT_MAP_SPECIAL_CHR);
2233 kfree(pfile_info);
2234 return rc;
2235}
2236
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002237static void
2238cleanup_volume_info(struct smb_vol **pvolume_info)
2239{
2240 struct smb_vol *volume_info;
2241
2242 if (!pvolume_info && !*pvolume_info)
2243 return;
2244
2245 volume_info = *pvolume_info;
2246 kzfree(volume_info->password);
2247 kfree(volume_info->UNC);
2248 kfree(volume_info->prepath);
2249 kfree(volume_info);
2250 *pvolume_info = NULL;
2251 return;
2252}
2253
Steve French2d6d5892009-04-09 00:36:44 +00002254#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002255/* build_path_to_root returns full path to root when
2256 * we do not have an exiting connection (tcon) */
2257static char *
2258build_unc_path_to_root(const struct smb_vol *volume_info,
2259 const struct cifs_sb_info *cifs_sb)
2260{
2261 char *full_path;
2262
2263 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2264 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2265 if (full_path == NULL)
2266 return ERR_PTR(-ENOMEM);
2267
2268 strncpy(full_path, volume_info->UNC, unc_len);
2269 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2270 int i;
2271 for (i = 0; i < unc_len; i++) {
2272 if (full_path[i] == '\\')
2273 full_path[i] = '/';
2274 }
2275 }
2276
2277 if (cifs_sb->prepathlen)
2278 strncpy(full_path + unc_len, cifs_sb->prepath,
2279 cifs_sb->prepathlen);
2280
2281 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2282 return full_path;
2283}
Steve French2d6d5892009-04-09 00:36:44 +00002284#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002285
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286int
2287cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002288 char *mount_data_global, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289{
2290 int rc = 0;
2291 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002292 struct smb_vol *volume_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 struct cifsSesInfo *pSesInfo = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 struct cifsTconInfo *tcon = NULL;
2295 struct TCP_Server_Info *srvTcp = NULL;
Igor Mammedove4cce942009-02-10 14:10:26 +03002296 char *full_path;
Steve French2d6d5892009-04-09 00:36:44 +00002297 char *mount_data = mount_data_global;
2298#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002299 struct dfs_info3_param *referrals = NULL;
2300 unsigned int num_referrals = 0;
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002301 int referral_walks_count = 0;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002302try_mount_again:
Steve French2d6d5892009-04-09 00:36:44 +00002303#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002304 full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
2306 xid = GetXid();
2307
Jeff Layton7586b762008-12-01 18:41:49 -05002308 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2309 if (!volume_info) {
2310 rc = -ENOMEM;
2311 goto out;
2312 }
Steve French50c2f752007-07-13 00:33:32 +00002313
Jeff Layton7586b762008-12-01 18:41:49 -05002314 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002315 rc = -EINVAL;
2316 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 }
2318
Jeff Layton7586b762008-12-01 18:41:49 -05002319 if (volume_info->nullauth) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002320 cFYI(1, ("null user"));
Jeff Layton7586b762008-12-01 18:41:49 -05002321 volume_info->username = "";
2322 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 /* BB fixme parse for domain name here */
Jeff Layton7586b762008-12-01 18:41:49 -05002324 cFYI(1, ("Username: %s", volume_info->username));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002326 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002327 /* In userspace mount helper we can get user name from alternate
2328 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002329 rc = -EINVAL;
2330 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 }
2332
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333
2334 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002335 if (volume_info->iocharset == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 cifs_sb->local_nls = load_nls_default();
2337 /* load_nls_default can not return null */
2338 } else {
Jeff Layton7586b762008-12-01 18:41:49 -05002339 cifs_sb->local_nls = load_nls(volume_info->iocharset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002340 if (cifs_sb->local_nls == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002341 cERROR(1, ("CIFS mount error: iocharset %s not found",
Jeff Layton7586b762008-12-01 18:41:49 -05002342 volume_info->iocharset));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002343 rc = -ELIBACC;
2344 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 }
2346 }
2347
Jeff Layton63c038c2008-12-01 18:41:46 -05002348 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002349 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002350 if (IS_ERR(srvTcp)) {
2351 rc = PTR_ERR(srvTcp);
2352 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 }
2354
Jeff Layton7586b762008-12-01 18:41:49 -05002355 pSesInfo = cifs_find_smb_ses(srvTcp, volume_info->username);
Jeff Layton14fbf502008-11-14 13:53:46 -05002356 if (pSesInfo) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002357 cFYI(1, ("Existing smb sess found (status=%d)",
2358 pSesInfo->status));
Jeff Layton14fbf502008-11-14 13:53:46 -05002359 /*
2360 * The existing SMB session already has a reference to srvTcp,
2361 * so we can put back the extra one we got before
2362 */
2363 cifs_put_tcp_session(srvTcp);
2364
Steve French88e7d702008-01-03 17:37:09 +00002365 down(&pSesInfo->sesSem);
Steve French3b795212008-11-13 19:45:32 +00002366 if (pSesInfo->need_reconnect) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002367 cFYI(1, ("Session needs reconnect"));
Jeff Layton1d9a8852007-12-31 01:37:11 +00002368 rc = cifs_setup_session(xid, pSesInfo,
2369 cifs_sb->local_nls);
Jeff Layton1d9a8852007-12-31 01:37:11 +00002370 }
Steve French88e7d702008-01-03 17:37:09 +00002371 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 } else if (!rc) {
Steve Frenchbf820672005-12-01 22:32:42 -08002373 cFYI(1, ("Existing smb sess not found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 pSesInfo = sesInfoAlloc();
Jeff Layton14fbf502008-11-14 13:53:46 -05002375 if (pSesInfo == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 rc = -ENOMEM;
Jeff Layton14fbf502008-11-14 13:53:46 -05002377 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 }
2379
Jeff Layton14fbf502008-11-14 13:53:46 -05002380 /* new SMB session uses our srvTcp ref */
2381 pSesInfo->server = srvTcp;
Jeff Layton63c038c2008-12-01 18:41:46 -05002382 if (srvTcp->addr.sockAddr6.sin6_family == AF_INET6)
Linus Torvalds0191b622008-12-28 12:49:40 -08002383 sprintf(pSesInfo->serverName, "%pI6",
2384 &srvTcp->addr.sockAddr6.sin6_addr);
Jeff Layton8ecaf672008-12-01 15:23:50 -05002385 else
Linus Torvalds0191b622008-12-28 12:49:40 -08002386 sprintf(pSesInfo->serverName, "%pI4",
2387 &srvTcp->addr.sockAddr.sin_addr.s_addr);
Jeff Layton14fbf502008-11-14 13:53:46 -05002388
2389 write_lock(&cifs_tcp_ses_lock);
2390 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2391 write_unlock(&cifs_tcp_ses_lock);
2392
Jeff Layton7586b762008-12-01 18:41:49 -05002393 /* volume_info->password freed at unmount */
2394 if (volume_info->password) {
Jeff Layton00e485b2008-12-05 20:41:21 -05002395 pSesInfo->password = kstrdup(volume_info->password,
2396 GFP_KERNEL);
2397 if (!pSesInfo->password) {
2398 rc = -ENOMEM;
2399 goto mount_fail_check;
2400 }
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002401 }
Jeff Layton7586b762008-12-01 18:41:49 -05002402 if (volume_info->username)
2403 strncpy(pSesInfo->userName, volume_info->username,
Jeff Layton14fbf502008-11-14 13:53:46 -05002404 MAX_USERNAME_SIZE);
Jeff Layton7586b762008-12-01 18:41:49 -05002405 if (volume_info->domainname) {
2406 int len = strlen(volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002407 pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2408 if (pSesInfo->domainName)
2409 strcpy(pSesInfo->domainName,
Jeff Layton7586b762008-12-01 18:41:49 -05002410 volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002411 }
Jeff Layton7586b762008-12-01 18:41:49 -05002412 pSesInfo->linux_uid = volume_info->linux_uid;
2413 pSesInfo->overrideSecFlg = volume_info->secFlg;
Jeff Layton14fbf502008-11-14 13:53:46 -05002414 down(&pSesInfo->sesSem);
2415
2416 /* BB FIXME need to pass vol->secFlgs BB */
2417 rc = cifs_setup_session(xid, pSesInfo,
2418 cifs_sb->local_nls);
2419 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 }
Steve French50c2f752007-07-13 00:33:32 +00002421
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 /* search for existing tcon to this server share */
2423 if (!rc) {
Jeff Layton7586b762008-12-01 18:41:49 -05002424 setup_cifs_sb(volume_info, cifs_sb);
Steve French0ae0efa2005-10-10 10:57:19 -07002425
Jeff Layton7586b762008-12-01 18:41:49 -05002426 tcon = cifs_find_tcon(pSesInfo, volume_info->UNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 if (tcon) {
Steve Frenchbf820672005-12-01 22:32:42 -08002428 cFYI(1, ("Found match on UNC path"));
Jeff Laytonf1987b42008-11-15 11:12:47 -05002429 /* existing tcon already has a reference */
2430 cifs_put_smb_ses(pSesInfo);
Jeff Layton7586b762008-12-01 18:41:49 -05002431 if (tcon->seal != volume_info->seal)
Steve French95b1cb92008-05-15 16:44:38 +00002432 cERROR(1, ("transport encryption setting "
2433 "conflicts with existing tid"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 } else {
2435 tcon = tconInfoAlloc();
Steve French3b795212008-11-13 19:45:32 +00002436 if (tcon == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437 rc = -ENOMEM;
Steve French3b795212008-11-13 19:45:32 +00002438 goto mount_fail_check;
2439 }
Jeff Layton00e485b2008-12-05 20:41:21 -05002440
Steve Frenchab3f9922008-11-17 16:03:00 +00002441 tcon->ses = pSesInfo;
Jeff Layton00e485b2008-12-05 20:41:21 -05002442 if (volume_info->password) {
2443 tcon->password = kstrdup(volume_info->password,
2444 GFP_KERNEL);
2445 if (!tcon->password) {
2446 rc = -ENOMEM;
2447 goto mount_fail_check;
2448 }
2449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450
Jeff Layton7586b762008-12-01 18:41:49 -05002451 if ((strchr(volume_info->UNC + 3, '\\') == NULL)
2452 && (strchr(volume_info->UNC + 3, '/') == NULL)) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002453 cERROR(1, ("Missing share name"));
Steve French3b795212008-11-13 19:45:32 +00002454 rc = -ENODEV;
2455 goto mount_fail_check;
2456 } else {
2457 /* BB Do we need to wrap sesSem around
2458 * this TCon call and Unix SetFS as
2459 * we do on SessSetup and reconnect? */
Jeff Layton7586b762008-12-01 18:41:49 -05002460 rc = CIFSTCon(xid, pSesInfo, volume_info->UNC,
Steve French3b795212008-11-13 19:45:32 +00002461 tcon, cifs_sb->local_nls);
2462 cFYI(1, ("CIFS Tcon rc = %d", rc));
Jeff Layton7586b762008-12-01 18:41:49 -05002463 if (volume_info->nodfs) {
Steve French3b795212008-11-13 19:45:32 +00002464 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2465 cFYI(1, ("DFS disabled (%d)",
2466 tcon->Flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 }
2468 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002469 if (rc)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002470 goto remote_path_check;
Jeff Layton7586b762008-12-01 18:41:49 -05002471 tcon->seal = volume_info->seal;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002472 write_lock(&cifs_tcp_ses_lock);
2473 list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2474 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 }
Steve French3b795212008-11-13 19:45:32 +00002476
2477 /* we can have only one retry value for a connection
2478 to a share so for resources mounted more than once
2479 to the same server share the last value passed in
2480 for the retry flag is used */
Jeff Layton7586b762008-12-01 18:41:49 -05002481 tcon->retry = volume_info->retry;
2482 tcon->nocase = volume_info->nocase;
2483 tcon->local_lease = volume_info->local_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 }
Steve French4523cc32007-04-30 20:13:06 +00002485 if (pSesInfo) {
Jeff Layton03aa3a42009-07-21 19:42:03 -04002486 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2487 sb->s_maxbytes = MAX_LFS_FILESIZE;
2488 else
2489 sb->s_maxbytes = MAX_NON_LFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 }
2491
Steve French8af18972007-02-14 04:42:51 +00002492 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 sb->s_time_gran = 100;
2494
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002495 if (rc)
2496 goto remote_path_check;
2497
Steve Frenchd82c2df2008-11-15 00:07:26 +00002498 cifs_sb->tcon = tcon;
Steve Frenchd82c2df2008-11-15 00:07:26 +00002499
2500 /* do not care if following two calls succeed - informational */
2501 if (!tcon->ipc) {
2502 CIFSSMBQFSDeviceInfo(xid, tcon);
2503 CIFSSMBQFSAttributeInfo(xid, tcon);
2504 }
2505
2506 /* tell server which Unix caps we support */
2507 if (tcon->ses->capabilities & CAP_UNIX)
2508 /* reset of caps checks mount to see if unix extensions
2509 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002510 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002511 else
2512 tcon->unix_ext = 0; /* server does not support them */
2513
2514 /* convert forward to back slashes in prepath here if needed */
2515 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2516 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2517
2518 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2519 cifs_sb->rsize = 1024 * 127;
2520 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2521 }
2522 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2523 cifs_sb->wsize = min(cifs_sb->wsize,
2524 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2525 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2526 cifs_sb->rsize = min(cifs_sb->rsize,
2527 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002529remote_path_check:
2530 /* check if a whole path (including prepath) is not remote */
2531 if (!rc && cifs_sb->prepathlen && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002532 /* build_path_to_root works only when we have a valid tcon */
2533 full_path = cifs_build_path_to_root(cifs_sb);
2534 if (full_path == NULL) {
2535 rc = -ENOMEM;
2536 goto mount_fail_check;
2537 }
2538 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002539 if (rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002540 kfree(full_path);
2541 goto mount_fail_check;
2542 }
2543 kfree(full_path);
2544 }
2545
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002546 /* get referral if needed */
2547 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00002548#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002549 if (referral_walks_count > MAX_NESTED_LINKS) {
2550 /*
2551 * BB: when we implement proper loop detection,
2552 * we will remove this check. But now we need it
2553 * to prevent an indefinite loop if 'DFS tree' is
2554 * misconfigured (i.e. has loops).
2555 */
2556 rc = -ELOOP;
2557 goto mount_fail_check;
2558 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002559 /* convert forward to back slashes in prepath here if needed */
2560 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2561 convert_delimiter(cifs_sb->prepath,
2562 CIFS_DIR_SEP(cifs_sb));
2563 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2564 if (IS_ERR(full_path)) {
2565 rc = PTR_ERR(full_path);
2566 goto mount_fail_check;
2567 }
2568
2569 cFYI(1, ("Getting referral for: %s", full_path));
2570 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2571 cifs_sb->local_nls, &num_referrals, &referrals,
2572 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2573 if (!rc && num_referrals > 0) {
2574 char *fake_devname = NULL;
2575
2576 if (mount_data != mount_data_global)
2577 kfree(mount_data);
Jeff Layton7b91e262009-07-23 15:22:30 -04002578
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002579 mount_data = cifs_compose_mount_options(
2580 cifs_sb->mountdata, full_path + 1,
2581 referrals, &fake_devname);
Jeff Layton7b91e262009-07-23 15:22:30 -04002582
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002583 free_dfs_info_array(referrals, num_referrals);
Jeff Layton7b91e262009-07-23 15:22:30 -04002584 kfree(fake_devname);
2585 kfree(full_path);
2586
2587 if (IS_ERR(mount_data)) {
2588 rc = PTR_ERR(mount_data);
2589 mount_data = NULL;
2590 goto mount_fail_check;
2591 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002592
2593 if (tcon)
2594 cifs_put_tcon(tcon);
2595 else if (pSesInfo)
2596 cifs_put_smb_ses(pSesInfo);
2597
2598 cleanup_volume_info(&volume_info);
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002599 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002600 goto try_mount_again;
2601 }
Steve Frenchd036f502009-04-03 03:12:08 +00002602#else /* No DFS support, return error on mount */
2603 rc = -EOPNOTSUPP;
2604#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002605 }
2606
2607mount_fail_check:
2608 /* on error free sesinfo and tcon struct if needed */
2609 if (rc) {
2610 if (mount_data != mount_data_global)
2611 kfree(mount_data);
2612 /* If find_unc succeeded then rc == 0 so we can not end */
2613 /* up accidently freeing someone elses tcon struct */
2614 if (tcon)
2615 cifs_put_tcon(tcon);
2616 else if (pSesInfo)
2617 cifs_put_smb_ses(pSesInfo);
2618 else
2619 cifs_put_tcp_session(srvTcp);
2620 goto out;
2621 }
2622
Jeff Layton7586b762008-12-01 18:41:49 -05002623 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 (in which case it is not needed anymore) but when new sesion is created
2625 the password ptr is put in the new session structure (in which case the
2626 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002627out:
2628 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002629 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 FreeXid(xid);
2631 return rc;
2632}
2633
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634int
2635CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2636 const char *tree, struct cifsTconInfo *tcon,
2637 const struct nls_table *nls_codepage)
2638{
2639 struct smb_hdr *smb_buffer;
2640 struct smb_hdr *smb_buffer_response;
2641 TCONX_REQ *pSMB;
2642 TCONX_RSP *pSMBr;
2643 unsigned char *bcc_ptr;
2644 int rc = 0;
Jeff Laytoncc20c032009-04-30 07:16:21 -04002645 int length, bytes_left;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 __u16 count;
2647
2648 if (ses == NULL)
2649 return -EIO;
2650
2651 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00002652 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00002654
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 smb_buffer_response = smb_buffer;
2656
2657 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2658 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07002659
2660 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 smb_buffer->Uid = ses->Suid;
2662 pSMB = (TCONX_REQ *) smb_buffer;
2663 pSMBr = (TCONX_RSP *) smb_buffer_response;
2664
2665 pSMB->AndXCommand = 0xFF;
2666 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002668 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08002669 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00002670 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08002671 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00002672 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08002673 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00002674 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08002675 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2676 specified as required (when that support is added to
2677 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00002678 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08002679 by Samba (not sure whether other servers allow
2680 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00002681#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French50c2f752007-07-13 00:33:32 +00002682 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05002683 (ses->server->secType == LANMAN))
2684 calc_lanman_hash(tcon->password, ses->server->cryptKey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05002685 ses->server->secMode &
2686 SECMODE_PW_ENCRYPT ? true : false,
2687 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00002688 else
2689#endif /* CIFS_WEAK_PW_HASH */
Jeff Layton00e485b2008-12-05 20:41:21 -05002690 SMBNTencrypt(tcon->password, ses->server->cryptKey,
Steve Frencheeac8042006-01-13 21:34:58 -08002691 bcc_ptr);
2692
Steve French7c7b25b2006-06-01 19:20:10 +00002693 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002694 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00002695 /* must align unicode strings */
2696 *bcc_ptr = 0; /* null byte password */
2697 bcc_ptr++;
2698 }
Steve Frencheeac8042006-01-13 21:34:58 -08002699 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700
Steve French50c2f752007-07-13 00:33:32 +00002701 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00002702 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2704
2705 if (ses->capabilities & CAP_STATUS32) {
2706 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2707 }
2708 if (ses->capabilities & CAP_DFS) {
2709 smb_buffer->Flags2 |= SMBFLG2_DFS;
2710 }
2711 if (ses->capabilities & CAP_UNICODE) {
2712 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2713 length =
Steve French50c2f752007-07-13 00:33:32 +00002714 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2715 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00002716 (/* server len*/ + 256 /* share len */), nls_codepage);
2717 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 bcc_ptr += 2; /* skip trailing null */
2719 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 strcpy(bcc_ptr, tree);
2721 bcc_ptr += strlen(tree) + 1;
2722 }
2723 strcpy(bcc_ptr, "?????");
2724 bcc_ptr += strlen("?????");
2725 bcc_ptr += 1;
2726 count = bcc_ptr - &pSMB->Password[0];
2727 pSMB->hdr.smb_buf_length += count;
2728 pSMB->ByteCount = cpu_to_le16(count);
2729
Steve French133672e2007-11-13 22:41:37 +00002730 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2731 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 /* above now done in SendReceive */
2734 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00002735 bool is_unicode;
2736
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00002738 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 tcon->tid = smb_buffer_response->Tid;
2740 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04002741 bytes_left = BCC(smb_buffer_response);
2742 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00002743 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
2744 is_unicode = true;
2745 else
2746 is_unicode = false;
2747
Jeff Laytoncc20c032009-04-30 07:16:21 -04002748
Steve French50c2f752007-07-13 00:33:32 +00002749 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00002750 if (length == 3) {
2751 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
2752 (bcc_ptr[2] == 'C')) {
2753 cFYI(1, ("IPC connection"));
2754 tcon->ipc = 1;
2755 }
2756 } else if (length == 2) {
2757 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
2758 /* the most common case */
2759 cFYI(1, ("disk share connection"));
2760 }
2761 }
Steve French50c2f752007-07-13 00:33:32 +00002762 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04002763 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04002765
2766 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04002767 kfree(tcon->nativeFileSystem);
Steve Frenchd185cda2009-04-30 17:45:10 +00002768 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00002769 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04002770 nls_codepage);
2771
2772 cFYI(1, ("nativeFileSystem=%s", tcon->nativeFileSystem));
2773
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002774 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00002775 (smb_buffer_response->WordCount == 7))
2776 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00002777 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
2778 else
2779 tcon->Flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
2781 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002782 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 ses->ipc_tid = smb_buffer_response->Tid;
2784 }
2785
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002786 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 return rc;
2788}
2789
2790int
2791cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
2792{
2793 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00002794 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795
Jeff Laytonf1987b42008-11-15 11:12:47 -05002796 if (cifs_sb->tcon)
2797 cifs_put_tcon(cifs_sb->tcon);
Steve French50c2f752007-07-13 00:33:32 +00002798
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799 cifs_sb->tcon = NULL;
Steve French2fe87f02006-09-21 07:02:52 +00002800 tmp = cifs_sb->prepath;
2801 cifs_sb->prepathlen = 0;
2802 cifs_sb->prepath = NULL;
2803 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804
Steve French88e7d702008-01-03 17:37:09 +00002805 return rc;
Steve French50c2f752007-07-13 00:33:32 +00002806}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807
2808int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
Steve French50c2f752007-07-13 00:33:32 +00002809 struct nls_table *nls_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810{
2811 int rc = 0;
Steve Frenchad009ac2005-04-28 22:41:05 -07002812 int first_time = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002813 struct TCP_Server_Info *server = pSesInfo->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814
2815 /* what if server changes its buffer size after dropping the session? */
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002816 if (server->maxBuf == 0) /* no need to send on reconnect */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 rc = CIFSSMBNegotiate(xid, pSesInfo);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002818 if (rc == -EAGAIN) {
2819 /* retry only once on 1st time connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve French50c2f752007-07-13 00:33:32 +00002821 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 rc = -EHOSTDOWN;
2823 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002824 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 spin_lock(&GlobalMid_Lock);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002826 if (server->tcpStatus != CifsExiting)
2827 server->tcpStatus = CifsGood;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 else
2829 rc = -EHOSTDOWN;
2830 spin_unlock(&GlobalMid_Lock);
2831
2832 }
Steve Frenchad009ac2005-04-28 22:41:05 -07002833 first_time = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 }
Steve French26b994f2008-08-06 05:11:33 +00002835
2836 if (rc)
2837 goto ss_err_exit;
2838
2839 pSesInfo->flags = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002840 pSesInfo->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00002841 if (linuxExtEnabled == 0)
2842 pSesInfo->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00002843
Steve French26b994f2008-08-06 05:11:33 +00002844 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002845 server->secMode, server->capabilities, server->timeAdj));
2846
Steve French20418ac2009-04-30 16:13:32 +00002847 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00002848 if (rc) {
2849 cERROR(1, ("Send error in SessSetup = %d", rc));
2850 } else {
2851 cFYI(1, ("CIFS Session Established successfully"));
Steve French20418ac2009-04-30 16:13:32 +00002852 spin_lock(&GlobalMid_Lock);
2853 pSesInfo->status = CifsGood;
2854 pSesInfo->need_reconnect = false;
2855 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00002856 }
2857
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858ss_err_exit:
2859 return rc;
2860}
2861