blob: 6926023af878a80e8f0aafd2f5d507886bdd35b3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve French366781c2008-01-25 10:12:41 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/uaccess.h>
36#include <asm/processor.h>
Steve French0e2beda2009-01-30 21:24:41 +000037#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "cifspdu.h"
39#include "cifsglob.h"
40#include "cifsproto.h"
41#include "cifs_unicode.h"
42#include "cifs_debug.h"
43#include "cifs_fs_sb.h"
44#include "ntlmssp.h"
45#include "nterr.h"
46#include "rfc1002pdu.h"
Steve Frencha2653eb2005-11-10 15:33:38 -080047#include "cn_cifs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49#define CIFS_PORT 445
50#define RFC1001_PORT 139
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
53 unsigned char *p24);
54
55extern mempool_t *cifs_req_poolp;
56
57struct smb_vol {
58 char *username;
59 char *password;
60 char *domainname;
61 char *UNC;
62 char *UNCip;
Steve French95b1cb92008-05-15 16:44:38 +000063 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 char *iocharset; /* local code page for mapping to and from Unicode */
65 char source_rfc1001_name[16]; /* netbios name of client */
Steve Frencha10faeb22005-08-22 21:38:31 -070066 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 uid_t linux_uid;
68 gid_t linux_gid;
69 mode_t file_mode;
70 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000071 unsigned secFlg;
Steve French4b18f2a2008-04-29 00:06:05 +000072 bool rw:1;
73 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];
806
807 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000808 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Linus Torvalds12e36b22006-10-13 08:09:29 -0700810 if (Local_System_Name[0] != 0)
Steve French50c2f752007-07-13 00:33:32 +0000811 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
Steve French2cd646a2006-09-28 19:43:08 +0000812 else {
Linus Torvalds12e36b22006-10-13 08:09:29 -0700813 char *nodename = utsname()->nodename;
Steve French50c2f752007-07-13 00:33:32 +0000814 int n = strnlen(nodename, 15);
815 memset(vol->source_rfc1001_name, 0x20, 15);
816 for (i = 0; i < n; i++) {
Steve French2cd646a2006-09-28 19:43:08 +0000817 /* does not have to be perfect mapping since field is
818 informational, only used for servers that do not support
819 port 445 and it can be overridden at mount time */
Linus Torvalds12e36b22006-10-13 08:09:29 -0700820 vol->source_rfc1001_name[i] = toupper(nodename[i]);
Steve French2cd646a2006-09-28 19:43:08 +0000821 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823 vol->source_rfc1001_name[15] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700824 /* null target name indicates to use *SMBSERVR default called name
825 if we end up sending RFC1001 session initialize */
826 vol->target_rfc1001_name[0] = 0;
David Howellsa001e5b2008-11-14 10:38:47 +1100827 vol->linux_uid = current_uid(); /* use current_euid() instead? */
828 vol->linux_gid = current_gid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 vol->dir_mode = S_IRWXUGO;
830 /* 2767 perms indicate mandatory locking support */
Steve French7505e052007-11-01 18:03:01 +0000831 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Steve French4b18f2a2008-04-29 00:06:05 +0000834 vol->rw = true;
Jeremy Allisonac670552005-06-22 17:26:35 -0700835 /* default is always to request posix paths. */
836 vol->posix_paths = 1;
837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 if (!options)
839 return 1;
840
Steve French50c2f752007-07-13 00:33:32 +0000841 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000842 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 separator[0] = options[4];
844 options += 5;
845 } else {
Steve French467a8f82007-06-27 22:41:32 +0000846 cFYI(1, ("Null separator not allowed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 }
848 }
Steve French50c2f752007-07-13 00:33:32 +0000849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 while ((data = strsep(&options, separator)) != NULL) {
851 if (!*data)
852 continue;
853 if ((value = strchr(data, '=')) != NULL)
854 *value++ = '\0';
855
Steve French50c2f752007-07-13 00:33:32 +0000856 /* Have to parse this before we parse for "user" */
857 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000859 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 vol->no_xattr = 1;
861 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000862 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 printk(KERN_WARNING
864 "CIFS: invalid or missing username\n");
865 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000866 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000867 /* null user, ie anonymous, authentication */
868 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
870 if (strnlen(value, 200) < 200) {
871 vol->username = value;
872 } else {
873 printk(KERN_WARNING "CIFS: username too long\n");
874 return 1;
875 }
876 } else if (strnicmp(data, "pass", 4) == 0) {
877 if (!value) {
878 vol->password = NULL;
879 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000880 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 /* check if string begins with double comma
882 since that would mean the password really
883 does start with a comma, and would not
884 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000885 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 vol->password = NULL;
887 continue;
888 }
889 }
890 temp_len = strlen(value);
891 /* removed password length check, NTLM passwords
892 can be arbitrarily long */
893
Steve French50c2f752007-07-13 00:33:32 +0000894 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 prematurely null terminated. Commas in password are
896 specified across the cifs mount interface by a double
897 comma ie ,, and a comma used as in other cases ie ','
898 as a parameter delimiter/separator is single and due
899 to the strsep above is temporarily zeroed. */
900
901 /* NB: password legally can have multiple commas and
902 the only illegal character in a password is null */
903
Steve French50c2f752007-07-13 00:33:32 +0000904 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700905 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 /* reinsert comma */
907 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000908 temp_len += 2; /* move after second comma */
909 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000911 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700912 separator[0]) {
913 /* skip second comma */
914 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000915 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 /* single comma indicating start
917 of next parm */
918 break;
919 }
920 }
921 temp_len++;
922 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000923 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 options = NULL;
925 } else {
926 value[temp_len] = 0;
927 /* point option to start of next parm */
928 options = value + temp_len + 1;
929 }
Steve French50c2f752007-07-13 00:33:32 +0000930 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 double commas to singles. Note that this ends up
932 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700933 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000934 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000935 printk(KERN_WARNING "CIFS: no memory "
936 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700937 return 1;
938 }
Steve French50c2f752007-07-13 00:33:32 +0000939 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000941 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700942 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 /* skip second comma */
944 i++;
945 }
946 }
947 vol->password[j] = 0;
948 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700949 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000950 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000951 printk(KERN_WARNING "CIFS: no memory "
952 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700953 return 1;
954 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 strcpy(vol->password, value);
956 }
957 } else if (strnicmp(data, "ip", 2) == 0) {
958 if (!value || !*value) {
959 vol->UNCip = NULL;
960 } else if (strnlen(value, 35) < 35) {
961 vol->UNCip = value;
962 } else {
Steve French50c2f752007-07-13 00:33:32 +0000963 printk(KERN_WARNING "CIFS: ip address "
964 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 return 1;
966 }
Steve French50c2f752007-07-13 00:33:32 +0000967 } else if (strnicmp(data, "sec", 3) == 0) {
968 if (!value || !*value) {
969 cERROR(1, ("no security value specified"));
970 continue;
971 } else if (strnicmp(value, "krb5i", 5) == 0) {
972 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000973 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800974 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000975 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
976 CIFSSEC_MAY_KRB5; */
977 cERROR(1, ("Krb5 cifs privacy not supported"));
Steve Frenchbf820672005-12-01 22:32:42 -0800978 return 1;
979 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000980 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchbf820672005-12-01 22:32:42 -0800981 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000982 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000983 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800984 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000985 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -0800986 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000987 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +0000988 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800989 } else if (strnicmp(value, "ntlm", 4) == 0) {
990 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +0000991 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -0800992 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +0000993 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +0000994 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +0000995#ifdef CONFIG_CIFS_WEAK_PW_HASH
996 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000997 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +0000998#endif
Steve Frenchbf820672005-12-01 22:32:42 -0800999 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001000 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001001 } else {
1002 cERROR(1, ("bad security option: %s", value));
1003 return 1;
1004 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 } else if ((strnicmp(data, "unc", 3) == 0)
1006 || (strnicmp(data, "target", 6) == 0)
1007 || (strnicmp(data, "path", 4) == 0)) {
1008 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001009 printk(KERN_WARNING "CIFS: invalid path to "
1010 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 return 1; /* needs_arg; */
1012 }
1013 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001014 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001015 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001017 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 if (strncmp(vol->UNC, "//", 2) == 0) {
1019 vol->UNC[0] = '\\';
1020 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001021 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001023 "CIFS: UNC Path does not begin "
1024 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 return 1;
1026 }
1027 } else {
1028 printk(KERN_WARNING "CIFS: UNC name too long\n");
1029 return 1;
1030 }
1031 } else if ((strnicmp(data, "domain", 3) == 0)
1032 || (strnicmp(data, "workgroup", 5) == 0)) {
1033 if (!value || !*value) {
1034 printk(KERN_WARNING "CIFS: invalid domain name\n");
1035 return 1; /* needs_arg; */
1036 }
1037 /* BB are there cases in which a comma can be valid in
1038 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001039 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 vol->domainname = value;
1041 cFYI(1, ("Domain name set"));
1042 } else {
Steve French50c2f752007-07-13 00:33:32 +00001043 printk(KERN_WARNING "CIFS: domain name too "
1044 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 return 1;
1046 }
Steve French50c2f752007-07-13 00:33:32 +00001047 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1048 if (!value || !*value) {
1049 printk(KERN_WARNING
1050 "CIFS: invalid path prefix\n");
1051 return 1; /* needs_argument */
1052 }
1053 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001054 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001055 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001056 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1057 if (vol->prepath == NULL)
1058 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001059 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001060 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001061 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001062 } else
Steve French50c2f752007-07-13 00:33:32 +00001063 strcpy(vol->prepath, value);
1064 cFYI(1, ("prefix path %s", vol->prepath));
1065 } else {
1066 printk(KERN_WARNING "CIFS: prefix too long\n");
1067 return 1;
1068 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 } else if (strnicmp(data, "iocharset", 9) == 0) {
1070 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001071 printk(KERN_WARNING "CIFS: invalid iocharset "
1072 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 return 1; /* needs_arg; */
1074 }
1075 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001076 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001078 /* if iocharset not set then load_nls_default
1079 is used by caller */
1080 cFYI(1, ("iocharset set to %s", value));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 } else {
Steve French63135e02007-07-17 17:34:02 +00001082 printk(KERN_WARNING "CIFS: iocharset name "
1083 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 return 1;
1085 }
1086 } else if (strnicmp(data, "uid", 3) == 0) {
1087 if (value && *value) {
1088 vol->linux_uid =
1089 simple_strtoul(value, &value, 0);
Steve French4523cc32007-04-30 20:13:06 +00001090 vol->override_uid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 }
1092 } else if (strnicmp(data, "gid", 3) == 0) {
1093 if (value && *value) {
1094 vol->linux_gid =
1095 simple_strtoul(value, &value, 0);
Steve French4523cc32007-04-30 20:13:06 +00001096 vol->override_gid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 }
1098 } else if (strnicmp(data, "file_mode", 4) == 0) {
1099 if (value && *value) {
1100 vol->file_mode =
1101 simple_strtoul(value, &value, 0);
1102 }
1103 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1104 if (value && *value) {
1105 vol->dir_mode =
1106 simple_strtoul(value, &value, 0);
1107 }
1108 } else if (strnicmp(data, "dirmode", 4) == 0) {
1109 if (value && *value) {
1110 vol->dir_mode =
1111 simple_strtoul(value, &value, 0);
1112 }
1113 } else if (strnicmp(data, "port", 4) == 0) {
1114 if (value && *value) {
1115 vol->port =
1116 simple_strtoul(value, &value, 0);
1117 }
1118 } else if (strnicmp(data, "rsize", 5) == 0) {
1119 if (value && *value) {
1120 vol->rsize =
1121 simple_strtoul(value, &value, 0);
1122 }
1123 } else if (strnicmp(data, "wsize", 5) == 0) {
1124 if (value && *value) {
1125 vol->wsize =
1126 simple_strtoul(value, &value, 0);
1127 }
1128 } else if (strnicmp(data, "sockopt", 5) == 0) {
1129 if (value && *value) {
1130 vol->sockopt =
1131 simple_strtoul(value, &value, 0);
1132 }
1133 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1134 if (!value || !*value || (*value == ' ')) {
Steve French63135e02007-07-17 17:34:02 +00001135 cFYI(1, ("invalid (empty) netbiosname"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 } else {
Steve French50c2f752007-07-13 00:33:32 +00001137 memset(vol->source_rfc1001_name, 0x20, 15);
1138 for (i = 0; i < 15; i++) {
1139 /* BB are there cases in which a comma can be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 valid in this workstation netbios name (and need
1141 special handling)? */
1142
1143 /* We do not uppercase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001144 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 break;
Steve French50c2f752007-07-13 00:33:32 +00001146 else
1147 vol->source_rfc1001_name[i] =
1148 value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 }
1150 /* The string has 16th byte zero still from
1151 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001152 if ((i == 15) && (value[i] != 0))
1153 printk(KERN_WARNING "CIFS: netbiosname"
1154 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001155 }
1156 } else if (strnicmp(data, "servern", 7) == 0) {
1157 /* servernetbiosname specified override *SMBSERVER */
1158 if (!value || !*value || (*value == ' ')) {
Steve French467a8f82007-06-27 22:41:32 +00001159 cFYI(1, ("empty server netbiosname specified"));
Steve Frencha10faeb22005-08-22 21:38:31 -07001160 } else {
1161 /* last byte, type, is 0x20 for servr type */
Steve French50c2f752007-07-13 00:33:32 +00001162 memset(vol->target_rfc1001_name, 0x20, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001163
Steve French50c2f752007-07-13 00:33:32 +00001164 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001165 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001166 valid in this workstation netbios name
1167 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001168
Steve French50c2f752007-07-13 00:33:32 +00001169 /* user or mount helper must uppercase
1170 the netbiosname */
1171 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001172 break;
1173 else
Steve French50c2f752007-07-13 00:33:32 +00001174 vol->target_rfc1001_name[i] =
1175 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001176 }
1177 /* The string has 16th byte zero still from
1178 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001179 if ((i == 15) && (value[i] != 0))
1180 printk(KERN_WARNING "CIFS: server net"
1181 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 }
1183 } else if (strnicmp(data, "credentials", 4) == 0) {
1184 /* ignore */
1185 } else if (strnicmp(data, "version", 3) == 0) {
1186 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001187 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 /* ignore */
1189 } else if (strnicmp(data, "rw", 2) == 0) {
Steve French4b18f2a2008-04-29 00:06:05 +00001190 vol->rw = true;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001191 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1192 vol->noblocksnd = 1;
1193 } else if (strnicmp(data, "noautotune", 10) == 0) {
1194 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 } else if ((strnicmp(data, "suid", 4) == 0) ||
1196 (strnicmp(data, "nosuid", 6) == 0) ||
1197 (strnicmp(data, "exec", 4) == 0) ||
1198 (strnicmp(data, "noexec", 6) == 0) ||
1199 (strnicmp(data, "nodev", 5) == 0) ||
1200 (strnicmp(data, "noauto", 6) == 0) ||
1201 (strnicmp(data, "dev", 3) == 0)) {
1202 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001203 uses these opts to set flags, and the flags are read
1204 by the kernel vfs layer before we get here (ie
1205 before read super) so there is no point trying to
1206 parse these options again and set anything and it
1207 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 continue;
1209 } else if (strnicmp(data, "ro", 2) == 0) {
Steve French4b18f2a2008-04-29 00:06:05 +00001210 vol->rw = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 } else if (strnicmp(data, "hard", 4) == 0) {
1212 vol->retry = 1;
1213 } else if (strnicmp(data, "soft", 4) == 0) {
1214 vol->retry = 0;
1215 } else if (strnicmp(data, "perm", 4) == 0) {
1216 vol->noperm = 0;
1217 } else if (strnicmp(data, "noperm", 6) == 0) {
1218 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001219 } else if (strnicmp(data, "mapchars", 8) == 0) {
1220 vol->remap = 1;
1221 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1222 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001223 } else if (strnicmp(data, "sfu", 3) == 0) {
1224 vol->sfu_emul = 1;
1225 } else if (strnicmp(data, "nosfu", 5) == 0) {
1226 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001227 } else if (strnicmp(data, "nodfs", 5) == 0) {
1228 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001229 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1230 vol->posix_paths = 1;
1231 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1232 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001233 } else if (strnicmp(data, "nounix", 6) == 0) {
1234 vol->no_linux_ext = 1;
1235 } else if (strnicmp(data, "nolinux", 7) == 0) {
1236 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001237 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001238 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001239 vol->nocase = 1;
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001240 } else if (strnicmp(data, "brl", 3) == 0) {
1241 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001242 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001243 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001244 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001245 /* turn off mandatory locking in mode
1246 if remote locking is turned off since the
1247 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001248 if (vol->file_mode ==
1249 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001250 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001251 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1252 /* will take the shorter form "forcemand" as well */
1253 /* This mount option will force use of mandatory
1254 (DOS/Windows style) byte range locks, instead of
1255 using posix advisory byte range locks, even if the
1256 Unix extensions are available and posix locks would
1257 be supported otherwise. If Unix extensions are not
1258 negotiated this has no effect since mandatory locks
1259 would be used (mandatory locks is all that those
1260 those servers support) */
1261 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 } else if (strnicmp(data, "setuids", 7) == 0) {
1263 vol->setuids = 1;
1264 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1265 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001266 } else if (strnicmp(data, "dynperm", 7) == 0) {
1267 vol->dynperm = true;
1268 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1269 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 } else if (strnicmp(data, "nohard", 6) == 0) {
1271 vol->retry = 0;
1272 } else if (strnicmp(data, "nosoft", 6) == 0) {
1273 vol->retry = 1;
1274 } else if (strnicmp(data, "nointr", 6) == 0) {
1275 vol->intr = 0;
1276 } else if (strnicmp(data, "intr", 4) == 0) {
1277 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001278 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1279 vol->nostrictsync = 1;
1280 } else if (strnicmp(data, "strictsync", 10) == 0) {
1281 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001282 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001284 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001286 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001287 vol->cifs_acl = 1;
1288 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1289 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001290 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001292 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001294#ifdef CONFIG_CIFS_EXPERIMENTAL
1295 } else if (strnicmp(data, "locallease", 6) == 0) {
1296 vol->local_lease = 1;
1297#endif
Steve French50c2f752007-07-13 00:33:32 +00001298 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001299 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001300 } else if (strnicmp(data, "seal", 4) == 0) {
1301 /* we do not do the following in secFlags because seal
1302 is a per tree connection (mount) not a per socket
1303 or per-smb connection option in the protocol */
1304 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1305 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001306 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001308 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001310 } else if (strnicmp(data, "in6_addr", 8) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 if (!value || !*value) {
1312 vol->in6_addr = NULL;
1313 } else if (strnlen(value, 49) == 48) {
1314 vol->in6_addr = value;
1315 } else {
Steve French50c2f752007-07-13 00:33:32 +00001316 printk(KERN_WARNING "CIFS: ip v6 address not "
1317 "48 characters long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 return 1;
1319 }
1320 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001321 printk(KERN_WARNING "CIFS: Mount option noac not "
1322 "supported. Instead set "
1323 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 } else
Steve French50c2f752007-07-13 00:33:32 +00001325 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1326 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 }
1328 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001329 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001330 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1331 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 return 1;
1333 }
1334 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001335 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001336 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001338 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 if (strncmp(vol->UNC, "//", 2) == 0) {
1340 vol->UNC[0] = '\\';
1341 vol->UNC[1] = '\\';
1342 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001343 printk(KERN_WARNING "CIFS: UNC Path does not "
1344 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 return 1;
1346 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001347 value = strpbrk(vol->UNC+2, "/\\");
1348 if (value)
1349 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 } else {
1351 printk(KERN_WARNING "CIFS: UNC name too long\n");
1352 return 1;
1353 }
1354 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001355 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 vol->UNCip = &vol->UNC[2];
1357
1358 return 0;
1359}
1360
Jeff Laytone7ddee92008-11-14 13:44:38 -05001361static struct TCP_Server_Info *
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001362cifs_find_tcp_session(struct sockaddr_storage *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363{
1364 struct list_head *tmp;
Jeff Laytone7ddee92008-11-14 13:44:38 -05001365 struct TCP_Server_Info *server;
1366 struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1367 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
Jeff Laytone7ddee92008-11-14 13:44:38 -05001369 write_lock(&cifs_tcp_ses_lock);
1370 list_for_each(tmp, &cifs_tcp_ses_list) {
1371 server = list_entry(tmp, struct TCP_Server_Info,
1372 tcp_ses_list);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001373 /*
1374 * the demux thread can exit on its own while still in CifsNew
1375 * so don't accept any sockets in that state. Since the
1376 * tcpStatus never changes back to CifsNew it's safe to check
1377 * for this without a lock.
1378 */
1379 if (server->tcpStatus == CifsNew)
Cyrill Gorcunov1b20d672008-05-09 18:17:21 +00001380 continue;
Steve French50c2f752007-07-13 00:33:32 +00001381
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001382 if (addr->ss_family == AF_INET &&
Jeff Laytone7ddee92008-11-14 13:44:38 -05001383 (addr4->sin_addr.s_addr !=
1384 server->addr.sockAddr.sin_addr.s_addr))
1385 continue;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001386 else if (addr->ss_family == AF_INET6 &&
Steve French0e2beda2009-01-30 21:24:41 +00001387 !ipv6_addr_equal(&server->addr.sockAddr6.sin6_addr,
1388 &addr6->sin6_addr))
Jeff Laytone7ddee92008-11-14 13:44:38 -05001389 continue;
Steve French50c2f752007-07-13 00:33:32 +00001390
Jeff Laytone7ddee92008-11-14 13:44:38 -05001391 ++server->srv_count;
1392 write_unlock(&cifs_tcp_ses_lock);
Steve Frenchd82c2df2008-11-15 00:07:26 +00001393 cFYI(1, ("Existing tcp session with server found"));
Jeff Laytone7ddee92008-11-14 13:44:38 -05001394 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 }
Jeff Laytone7ddee92008-11-14 13:44:38 -05001396 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 return NULL;
1398}
1399
Jeff Layton14fbf502008-11-14 13:53:46 -05001400static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001401cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001403 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
Jeff Laytone7ddee92008-11-14 13:44:38 -05001405 write_lock(&cifs_tcp_ses_lock);
1406 if (--server->srv_count > 0) {
1407 write_unlock(&cifs_tcp_ses_lock);
1408 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001410
Jeff Laytone7ddee92008-11-14 13:44:38 -05001411 list_del_init(&server->tcp_ses_list);
1412 write_unlock(&cifs_tcp_ses_lock);
1413
1414 spin_lock(&GlobalMid_Lock);
1415 server->tcpStatus = CifsExiting;
1416 spin_unlock(&GlobalMid_Lock);
1417
1418 task = xchg(&server->tsk, NULL);
1419 if (task)
1420 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421}
1422
Jeff Layton63c038c2008-12-01 18:41:46 -05001423static struct TCP_Server_Info *
1424cifs_get_tcp_session(struct smb_vol *volume_info)
1425{
1426 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001427 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001428 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1429 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1430 int rc;
1431
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001432 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001433
1434 if (volume_info->UNCip && volume_info->UNC) {
1435 rc = cifs_inet_pton(AF_INET, volume_info->UNCip,
1436 &sin_server->sin_addr.s_addr);
1437
1438 if (rc <= 0) {
1439 /* not ipv4 address, try ipv6 */
1440 rc = cifs_inet_pton(AF_INET6, volume_info->UNCip,
1441 &sin_server6->sin6_addr.in6_u);
1442 if (rc > 0)
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001443 addr.ss_family = AF_INET6;
Jeff Layton63c038c2008-12-01 18:41:46 -05001444 } else {
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001445 addr.ss_family = AF_INET;
Jeff Layton63c038c2008-12-01 18:41:46 -05001446 }
1447
1448 if (rc <= 0) {
1449 /* we failed translating address */
1450 rc = -EINVAL;
1451 goto out_err;
1452 }
1453
1454 cFYI(1, ("UNC: %s ip: %s", volume_info->UNC,
1455 volume_info->UNCip));
1456 } else if (volume_info->UNCip) {
1457 /* BB using ip addr as tcp_ses name to connect to the
1458 DFS root below */
1459 cERROR(1, ("Connecting to DFS root not implemented yet"));
1460 rc = -EINVAL;
1461 goto out_err;
1462 } else /* which tcp_sess DFS root would we conect to */ {
1463 cERROR(1,
1464 ("CIFS mount error: No UNC path (e.g. -o "
1465 "unc=//192.168.1.100/public) specified"));
1466 rc = -EINVAL;
1467 goto out_err;
1468 }
1469
1470 /* see if we already have a matching tcp_ses */
1471 tcp_ses = cifs_find_tcp_session(&addr);
1472 if (tcp_ses)
1473 return tcp_ses;
1474
1475 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1476 if (!tcp_ses) {
1477 rc = -ENOMEM;
1478 goto out_err;
1479 }
1480
1481 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1482 if (IS_ERR(tcp_ses->hostname)) {
1483 rc = PTR_ERR(tcp_ses->hostname);
1484 goto out_err;
1485 }
1486
1487 tcp_ses->noblocksnd = volume_info->noblocksnd;
1488 tcp_ses->noautotune = volume_info->noautotune;
1489 atomic_set(&tcp_ses->inFlight, 0);
1490 init_waitqueue_head(&tcp_ses->response_q);
1491 init_waitqueue_head(&tcp_ses->request_q);
1492 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1493 mutex_init(&tcp_ses->srv_mutex);
1494 memcpy(tcp_ses->workstation_RFC1001_name,
1495 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1496 memcpy(tcp_ses->server_RFC1001_name,
1497 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1498 tcp_ses->sequence_number = 0;
1499 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1500 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1501
1502 /*
1503 * at this point we are the only ones with the pointer
1504 * to the struct since the kernel thread not created yet
1505 * no need to spinlock this init of tcpStatus or srv_count
1506 */
1507 tcp_ses->tcpStatus = CifsNew;
1508 ++tcp_ses->srv_count;
1509
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001510 if (addr.ss_family == AF_INET6) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001511 cFYI(1, ("attempting ipv6 connect"));
1512 /* BB should we allow ipv6 on port 139? */
1513 /* other OS never observed in Wild doing 139 with v6 */
1514 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1515 sizeof(struct sockaddr_in6));
1516 sin_server6->sin6_port = htons(volume_info->port);
Jeff Laytond5c56052008-12-01 18:42:33 -05001517 rc = ipv6_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001518 } else {
1519 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1520 sizeof(struct sockaddr_in));
1521 sin_server->sin_port = htons(volume_info->port);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001522 rc = ipv4_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001523 }
1524 if (rc < 0) {
1525 cERROR(1, ("Error connecting to socket. Aborting operation"));
1526 goto out_err;
1527 }
1528
1529 /*
1530 * since we're in a cifs function already, we know that
1531 * this will succeed. No need for try_module_get().
1532 */
1533 __module_get(THIS_MODULE);
1534 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1535 tcp_ses, "cifsd");
1536 if (IS_ERR(tcp_ses->tsk)) {
1537 rc = PTR_ERR(tcp_ses->tsk);
1538 cERROR(1, ("error %d create cifsd thread", rc));
1539 module_put(THIS_MODULE);
1540 goto out_err;
1541 }
1542
1543 /* thread spawned, put it on the list */
1544 write_lock(&cifs_tcp_ses_lock);
1545 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1546 write_unlock(&cifs_tcp_ses_lock);
1547
1548 return tcp_ses;
1549
1550out_err:
1551 if (tcp_ses) {
1552 kfree(tcp_ses->hostname);
1553 if (tcp_ses->ssocket)
1554 sock_release(tcp_ses->ssocket);
1555 kfree(tcp_ses);
1556 }
1557 return ERR_PTR(rc);
1558}
1559
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560static struct cifsSesInfo *
Jeff Layton14fbf502008-11-14 13:53:46 -05001561cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562{
1563 struct list_head *tmp;
1564 struct cifsSesInfo *ses;
1565
Jeff Layton14fbf502008-11-14 13:53:46 -05001566 write_lock(&cifs_tcp_ses_lock);
1567 list_for_each(tmp, &server->smb_ses_list) {
1568 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1569 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 continue;
1571
Jeff Layton14fbf502008-11-14 13:53:46 -05001572 ++ses->ses_count;
1573 write_unlock(&cifs_tcp_ses_lock);
1574 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001576 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 return NULL;
1578}
1579
Jeff Layton14fbf502008-11-14 13:53:46 -05001580static void
1581cifs_put_smb_ses(struct cifsSesInfo *ses)
1582{
1583 int xid;
1584 struct TCP_Server_Info *server = ses->server;
1585
1586 write_lock(&cifs_tcp_ses_lock);
1587 if (--ses->ses_count > 0) {
1588 write_unlock(&cifs_tcp_ses_lock);
1589 return;
1590 }
1591
1592 list_del_init(&ses->smb_ses_list);
1593 write_unlock(&cifs_tcp_ses_lock);
1594
1595 if (ses->status == CifsGood) {
1596 xid = GetXid();
1597 CIFSSMBLogoff(xid, ses);
1598 _FreeXid(xid);
1599 }
1600 sesInfoFree(ses);
1601 cifs_put_tcp_session(server);
1602}
1603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05001605cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
1607 struct list_head *tmp;
1608 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
Jeff Laytonf1987b42008-11-15 11:12:47 -05001610 write_lock(&cifs_tcp_ses_lock);
1611 list_for_each(tmp, &ses->tcon_list) {
1612 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1613 if (tcon->tidStatus == CifsExiting)
1614 continue;
1615 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 continue;
1617
Jeff Laytonf1987b42008-11-15 11:12:47 -05001618 ++tcon->tc_count;
1619 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 return tcon;
1621 }
Jeff Laytonf1987b42008-11-15 11:12:47 -05001622 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 return NULL;
1624}
1625
Jeff Laytonf1987b42008-11-15 11:12:47 -05001626static void
1627cifs_put_tcon(struct cifsTconInfo *tcon)
1628{
1629 int xid;
1630 struct cifsSesInfo *ses = tcon->ses;
1631
1632 write_lock(&cifs_tcp_ses_lock);
1633 if (--tcon->tc_count > 0) {
1634 write_unlock(&cifs_tcp_ses_lock);
1635 return;
1636 }
1637
1638 list_del_init(&tcon->tcon_list);
1639 write_unlock(&cifs_tcp_ses_lock);
1640
1641 xid = GetXid();
1642 CIFSSMBTDis(xid, tcon);
1643 _FreeXid(xid);
1644
1645 DeleteTconOplockQEntries(tcon);
1646 tconInfoFree(tcon);
1647 cifs_put_smb_ses(ses);
1648}
1649
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650int
Steve French50c2f752007-07-13 00:33:32 +00001651get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1652 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00001653 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654{
1655 char *temp_unc;
1656 int rc = 0;
1657
1658 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00001659 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 if (pSesInfo->ipc_tid == 0) {
1662 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00001663 strnlen(pSesInfo->serverName,
1664 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 + 1 + 4 /* slash IPC$ */ + 2,
1666 GFP_KERNEL);
1667 if (temp_unc == NULL)
1668 return -ENOMEM;
1669 temp_unc[0] = '\\';
1670 temp_unc[1] = '\\';
1671 strcpy(temp_unc + 2, pSesInfo->serverName);
1672 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1673 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1674 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00001675 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 kfree(temp_unc);
1677 }
1678 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00001679 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07001680 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00001681 /* BB map targetUNCs to dfs_info3 structures, here or
1682 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683
1684 return rc;
1685}
1686
Jeff Layton09e50d52008-07-23 10:11:19 -04001687#ifdef CONFIG_DEBUG_LOCK_ALLOC
1688static struct lock_class_key cifs_key[2];
1689static struct lock_class_key cifs_slock_key[2];
1690
1691static inline void
1692cifs_reclassify_socket4(struct socket *sock)
1693{
1694 struct sock *sk = sock->sk;
1695 BUG_ON(sock_owned_by_user(sk));
1696 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1697 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1698}
1699
1700static inline void
1701cifs_reclassify_socket6(struct socket *sock)
1702{
1703 struct sock *sk = sock->sk;
1704 BUG_ON(sock_owned_by_user(sk));
1705 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1706 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1707}
1708#else
1709static inline void
1710cifs_reclassify_socket4(struct socket *sock)
1711{
1712}
1713
1714static inline void
1715cifs_reclassify_socket6(struct socket *sock)
1716{
1717}
1718#endif
1719
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00001721static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722{
Steve French50c2f752007-07-13 00:33:32 +00001723 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Steve French50c2f752007-07-13 00:33:32 +00001725 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 /* mask a nibble at a time and encode */
1727 target[j] = 'A' + (0x0F & (source[i] >> 4));
1728 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00001729 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 }
1731
1732}
1733
1734
1735static int
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001736ipv4_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737{
1738 int rc = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001739 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 __be16 orig_port = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001741 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001743 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001744 rc = sock_create_kern(PF_INET, SOCK_STREAM,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001745 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001747 cERROR(1, ("Error %d creating socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001750
1751 /* BB other socket options to set KEEPALIVE, NODELAY? */
1752 cFYI(1, ("Socket created"));
1753 server->ssocket = socket;
1754 socket->sk->sk_allocation = GFP_NOFS;
1755 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 }
1757
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001758 /* user overrode default port */
1759 if (server->addr.sockAddr.sin_port) {
1760 rc = socket->ops->connect(socket, (struct sockaddr *)
1761 &server->addr.sockAddr,
1762 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001764 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001767 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001768 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 later if fall back ports fail this time */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001770 orig_port = server->addr.sockAddr.sin_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
1772 /* do not retry on the same port we just failed on */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001773 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
1774 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
1775 rc = socket->ops->connect(socket,
1776 (struct sockaddr *)
1777 &server->addr.sockAddr,
1778 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001780 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 }
1782 }
1783 if (!connected) {
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001784 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
1785 rc = socket->ops->connect(socket, (struct sockaddr *)
1786 &server->addr.sockAddr,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001787 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00001788 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001789 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 }
1791
1792 /* give up here - unless we want to retry on different
1793 protocol families some day */
1794 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001795 if (orig_port)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001796 server->addr.sockAddr.sin_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001797 cFYI(1, ("Error %d connecting to server via ipv4", rc));
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001798 sock_release(socket);
1799 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 return rc;
1801 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001802
1803
1804 /*
1805 * Eventually check for other socket options to change from
1806 * the default. sock_setsockopt not used because it expects
1807 * user space buffer
1808 */
1809 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001810 socket->sk->sk_sndtimeo = 5 * HZ;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001811
Steve Frenchb387eae2005-10-10 14:21:15 -07001812 /* make the bufsizes depend on wsize/rsize and max requests */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001813 if (server->noautotune) {
1814 if (socket->sk->sk_sndbuf < (200 * 1024))
1815 socket->sk->sk_sndbuf = 200 * 1024;
1816 if (socket->sk->sk_rcvbuf < (140 * 1024))
1817 socket->sk->sk_rcvbuf = 140 * 1024;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001820 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1821 socket->sk->sk_sndbuf,
1822 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo));
1823
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 /* send RFC1001 sessinit */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001825 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00001827 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00001829 struct rfc1002_session_packet *ses_init_buf;
1830 struct smb_hdr *smb_buf;
1831 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1832 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001833 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 ses_init_buf->trailer.session_req.called_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001835 if (server->server_RFC1001_name &&
1836 server->server_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001837 rfc1002mangle(ses_init_buf->trailer.
1838 session_req.called_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001839 server->server_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001840 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001841 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001842 rfc1002mangle(ses_init_buf->trailer.
1843 session_req.called_name,
1844 DEFAULT_CIFS_CALLED_NAME,
1845 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001846
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 ses_init_buf->trailer.session_req.calling_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001848
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 /* calling name ends in null (byte 16) from old smb
1850 convention. */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001851 if (server->workstation_RFC1001_name &&
1852 server->workstation_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001853 rfc1002mangle(ses_init_buf->trailer.
1854 session_req.calling_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001855 server->workstation_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001856 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001857 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001858 rfc1002mangle(ses_init_buf->trailer.
1859 session_req.calling_name,
1860 "LINUX_CIFS_CLNT",
1861 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001862
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 ses_init_buf->trailer.session_req.scope1 = 0;
1864 ses_init_buf->trailer.session_req.scope2 = 0;
1865 smb_buf = (struct smb_hdr *)ses_init_buf;
1866 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1867 smb_buf->smb_buf_length = 0x81000044;
Jeff Layton0496e022008-12-30 12:39:16 -05001868 rc = smb_send(server, smb_buf, 0x44);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00001870 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00001871 requires very short break before negprot
1872 presumably because not expecting negprot
1873 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00001874 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00001875 complicating the code and causes no
1876 significant slowing down on mount
1877 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 }
Steve French50c2f752007-07-13 00:33:32 +00001879 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00001881
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 }
Steve French50c2f752007-07-13 00:33:32 +00001883
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 return rc;
1885}
1886
1887static int
Jeff Laytond5c56052008-12-01 18:42:33 -05001888ipv6_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889{
1890 int rc = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001891 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 __be16 orig_port = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001893 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894
Jeff Laytond5c56052008-12-01 18:42:33 -05001895 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001896 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
Jeff Laytond5c56052008-12-01 18:42:33 -05001897 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001899 cERROR(1, ("Error %d creating ipv6 socket", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001900 socket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 }
Jeff Laytond5c56052008-12-01 18:42:33 -05001903
1904 /* BB other socket options to set KEEPALIVE, NODELAY? */
1905 cFYI(1, ("ipv6 Socket created"));
1906 server->ssocket = socket;
1907 socket->sk->sk_allocation = GFP_NOFS;
1908 cifs_reclassify_socket6(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 }
1910
Jeff Laytond5c56052008-12-01 18:42:33 -05001911 /* user overrode default port */
1912 if (server->addr.sockAddr6.sin6_port) {
1913 rc = socket->ops->connect(socket,
1914 (struct sockaddr *) &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001915 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001917 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001920 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001921 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 later if fall back ports fail this time */
1923
Jeff Laytond5c56052008-12-01 18:42:33 -05001924 orig_port = server->addr.sockAddr6.sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 /* do not retry on the same port we just failed on */
Jeff Laytond5c56052008-12-01 18:42:33 -05001926 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
1927 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
1928 rc = socket->ops->connect(socket, (struct sockaddr *)
1929 &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001930 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001932 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 }
1934 }
1935 if (!connected) {
Jeff Laytond5c56052008-12-01 18:42:33 -05001936 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
1937 rc = socket->ops->connect(socket, (struct sockaddr *)
1938 &server->addr.sockAddr6,
1939 sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00001940 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001941 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 }
1943
1944 /* give up here - unless we want to retry on different
1945 protocol families some day */
1946 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001947 if (orig_port)
Jeff Laytond5c56052008-12-01 18:42:33 -05001948 server->addr.sockAddr6.sin6_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001949 cFYI(1, ("Error %d connecting to server via ipv6", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001950 sock_release(socket);
1951 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 return rc;
1953 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00001954
Jeff Laytond5c56052008-12-01 18:42:33 -05001955 /*
1956 * Eventually check for other socket options to change from
1957 * the default. sock_setsockopt not used because it expects
1958 * user space buffer
1959 */
1960 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001961 socket->sk->sk_sndtimeo = 5 * HZ;
Jeff Laytond5c56052008-12-01 18:42:33 -05001962 server->ssocket = socket;
Steve French50c2f752007-07-13 00:33:32 +00001963
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 return rc;
1965}
1966
Steve French50c2f752007-07-13 00:33:32 +00001967void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1968 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00001969{
1970 /* if we are reconnecting then should we check to see if
1971 * any requested capabilities changed locally e.g. via
1972 * remount but we can not do much about it here
1973 * if they have (even if we could detect it by the following)
1974 * Perhaps we could add a backpointer to array of sb from tcon
1975 * or if we change to make all sb to same share the same
1976 * sb as NFS - then we only have one backpointer to sb.
1977 * What if we wanted to mount the server share twice once with
1978 * and once without posixacls or posix paths? */
1979 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001980
Steve Frenchc18c8422007-07-18 23:21:09 +00001981 if (vol_info && vol_info->no_linux_ext) {
1982 tcon->fsUnixInfo.Capability = 0;
1983 tcon->unix_ext = 0; /* Unix Extensions disabled */
1984 cFYI(1, ("Linux protocol extensions disabled"));
1985 return;
1986 } else if (vol_info)
1987 tcon->unix_ext = 1; /* Unix Extensions supported */
1988
1989 if (tcon->unix_ext == 0) {
1990 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1991 return;
1992 }
Steve French50c2f752007-07-13 00:33:32 +00001993
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001994 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00001995 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001996
Steve French8af18972007-02-14 04:42:51 +00001997 /* check for reconnect case in which we do not
1998 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001999 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002000 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002001 originally at mount time */
2002 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2003 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002004 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2005 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2006 cERROR(1, ("POSIXPATH support change"));
Steve French8af18972007-02-14 04:42:51 +00002007 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002008 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2009 cERROR(1, ("possible reconnect error"));
2010 cERROR(1,
2011 ("server disabled POSIX path support"));
2012 }
Steve French8af18972007-02-14 04:42:51 +00002013 }
Steve French50c2f752007-07-13 00:33:32 +00002014
Steve French8af18972007-02-14 04:42:51 +00002015 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002016 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002017 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002018 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002019 cFYI(1, ("negotiated posix acl support"));
2020 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002021 sb->s_flags |= MS_POSIXACL;
2022 }
2023
Steve French75865f8c2007-06-24 18:30:48 +00002024 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002025 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002026 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002027 cFYI(1, ("negotiate posix pathnames"));
Steve French75865f8c2007-06-24 18:30:48 +00002028 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002029 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002030 CIFS_MOUNT_POSIX_PATHS;
2031 }
Steve French50c2f752007-07-13 00:33:32 +00002032
Steve French984acfe2007-04-26 16:42:50 +00002033 /* We might be setting the path sep back to a different
2034 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002035 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002036 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002037 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002038
2039 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2040 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2041 CIFS_SB(sb)->rsize = 127 * 1024;
Steve French90c81e02008-02-12 20:32:36 +00002042 cFYI(DBG2,
2043 ("larger reads not supported by srv"));
Steve French75865f8c2007-06-24 18:30:48 +00002044 }
2045 }
Steve French50c2f752007-07-13 00:33:32 +00002046
2047
2048 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
Steve French8af18972007-02-14 04:42:51 +00002049#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002050 if (cap & CIFS_UNIX_FCNTL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002051 cFYI(1, ("FCNTL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002052 if (cap & CIFS_UNIX_EXTATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002053 cFYI(1, ("EXTATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002054 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002055 cFYI(1, ("POSIX path cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002056 if (cap & CIFS_UNIX_XATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002057 cFYI(1, ("XATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002058 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002059 cFYI(1, ("POSIX ACL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002060 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002061 cFYI(1, ("very large read cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002062 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002063 cFYI(1, ("very large write cap"));
Steve French8af18972007-02-14 04:42:51 +00002064#endif /* CIFS_DEBUG2 */
2065 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002066 if (vol_info == NULL) {
Steve French5a44b312007-09-20 15:16:24 +00002067 cFYI(1, ("resetting capabilities failed"));
Steve French442aa312007-09-24 20:25:46 +00002068 } else
Steve French5a44b312007-09-20 15:16:24 +00002069 cERROR(1, ("Negotiating Unix capabilities "
2070 "with the server failed. Consider "
2071 "mounting with the Unix Extensions\n"
2072 "disabled, if problems are found, "
2073 "by specifying the nounix mount "
Steve French2224f4e2007-09-20 15:37:29 +00002074 "option."));
Steve French5a44b312007-09-20 15:16:24 +00002075
Steve French8af18972007-02-14 04:42:51 +00002076 }
2077 }
2078}
2079
Steve French03a143c2008-02-14 06:38:30 +00002080static void
2081convert_delimiter(char *path, char delim)
2082{
2083 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002084 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002085
2086 if (path == NULL)
2087 return;
2088
Steve French582d21e2008-05-13 04:54:12 +00002089 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002090 old_delim = '\\';
2091 else
2092 old_delim = '/';
2093
Steve French03a143c2008-02-14 06:38:30 +00002094 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002095 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002096 path[i] = delim;
2097 }
2098}
2099
Steve French3b795212008-11-13 19:45:32 +00002100static void setup_cifs_sb(struct smb_vol *pvolume_info,
2101 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002102{
Steve French3b795212008-11-13 19:45:32 +00002103 if (pvolume_info->rsize > CIFSMaxBufSize) {
2104 cERROR(1, ("rsize %d too large, using MaxBufSize",
2105 pvolume_info->rsize));
2106 cifs_sb->rsize = CIFSMaxBufSize;
2107 } else if ((pvolume_info->rsize) &&
2108 (pvolume_info->rsize <= CIFSMaxBufSize))
2109 cifs_sb->rsize = pvolume_info->rsize;
2110 else /* default */
2111 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002112
Steve French3b795212008-11-13 19:45:32 +00002113 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2114 cERROR(1, ("wsize %d too large, using 4096 instead",
2115 pvolume_info->wsize));
2116 cifs_sb->wsize = 4096;
2117 } else if (pvolume_info->wsize)
2118 cifs_sb->wsize = pvolume_info->wsize;
2119 else
2120 cifs_sb->wsize = min_t(const int,
2121 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2122 127*1024);
2123 /* old default of CIFSMaxBufSize was too small now
2124 that SMB Write2 can send multiple pages in kvec.
2125 RFC1001 does not describe what happens when frame
2126 bigger than 128K is sent so use that as max in
2127 conjunction with 52K kvec constraint on arch with 4K
2128 page size */
2129
2130 if (cifs_sb->rsize < 2048) {
2131 cifs_sb->rsize = 2048;
2132 /* Windows ME may prefer this */
2133 cFYI(1, ("readsize set to minimum: 2048"));
2134 }
2135 /* calculate prepath */
2136 cifs_sb->prepath = pvolume_info->prepath;
2137 if (cifs_sb->prepath) {
2138 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2139 /* we can not convert the / to \ in the path
2140 separators in the prefixpath yet because we do not
2141 know (until reset_cifs_unix_caps is called later)
2142 whether POSIX PATH CAP is available. We normalize
2143 the / to \ after reset_cifs_unix_caps is called */
2144 pvolume_info->prepath = NULL;
2145 } else
2146 cifs_sb->prepathlen = 0;
2147 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2148 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2149 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2150 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2151 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2152 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2153
2154 if (pvolume_info->noperm)
2155 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2156 if (pvolume_info->setuids)
2157 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2158 if (pvolume_info->server_ino)
2159 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2160 if (pvolume_info->remap)
2161 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2162 if (pvolume_info->no_xattr)
2163 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2164 if (pvolume_info->sfu_emul)
2165 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2166 if (pvolume_info->nobrl)
2167 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002168 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002169 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002170 if (pvolume_info->mand_lock)
2171 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002172 if (pvolume_info->cifs_acl)
2173 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2174 if (pvolume_info->override_uid)
2175 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2176 if (pvolume_info->override_gid)
2177 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2178 if (pvolume_info->dynperm)
2179 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2180 if (pvolume_info->direct_io) {
2181 cFYI(1, ("mounting share using direct i/o"));
2182 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2183 }
2184
2185 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2186 cERROR(1, ("mount option dynperm ignored if cifsacl "
2187 "mount option supported"));
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002188}
2189
Igor Mammedove4cce942009-02-10 14:10:26 +03002190static int
2191is_path_accessible(int xid, struct cifsTconInfo *tcon,
2192 struct cifs_sb_info *cifs_sb, const char *full_path)
2193{
2194 int rc;
2195 __u64 inode_num;
2196 FILE_ALL_INFO *pfile_info;
2197
2198 rc = CIFSGetSrvInodeNumber(xid, tcon, full_path, &inode_num,
2199 cifs_sb->local_nls,
2200 cifs_sb->mnt_cifs_flags &
2201 CIFS_MOUNT_MAP_SPECIAL_CHR);
2202 if (rc != -EOPNOTSUPP)
2203 return rc;
2204
2205 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2206 if (pfile_info == NULL)
2207 return -ENOMEM;
2208
2209 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2210 0 /* not legacy */, cifs_sb->local_nls,
2211 cifs_sb->mnt_cifs_flags &
2212 CIFS_MOUNT_MAP_SPECIAL_CHR);
2213 kfree(pfile_info);
2214 return rc;
2215}
2216
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002217static void
2218cleanup_volume_info(struct smb_vol **pvolume_info)
2219{
2220 struct smb_vol *volume_info;
2221
2222 if (!pvolume_info && !*pvolume_info)
2223 return;
2224
2225 volume_info = *pvolume_info;
2226 kzfree(volume_info->password);
2227 kfree(volume_info->UNC);
2228 kfree(volume_info->prepath);
2229 kfree(volume_info);
2230 *pvolume_info = NULL;
2231 return;
2232}
2233
2234/* build_path_to_root returns full path to root when
2235 * we do not have an exiting connection (tcon) */
2236static char *
2237build_unc_path_to_root(const struct smb_vol *volume_info,
2238 const struct cifs_sb_info *cifs_sb)
2239{
2240 char *full_path;
2241
2242 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2243 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2244 if (full_path == NULL)
2245 return ERR_PTR(-ENOMEM);
2246
2247 strncpy(full_path, volume_info->UNC, unc_len);
2248 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2249 int i;
2250 for (i = 0; i < unc_len; i++) {
2251 if (full_path[i] == '\\')
2252 full_path[i] = '/';
2253 }
2254 }
2255
2256 if (cifs_sb->prepathlen)
2257 strncpy(full_path + unc_len, cifs_sb->prepath,
2258 cifs_sb->prepathlen);
2259
2260 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2261 return full_path;
2262}
2263
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264int
2265cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002266 char *mount_data_global, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267{
2268 int rc = 0;
2269 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002270 struct smb_vol *volume_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 struct cifsSesInfo *pSesInfo = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 struct cifsTconInfo *tcon = NULL;
2273 struct TCP_Server_Info *srvTcp = NULL;
Igor Mammedove4cce942009-02-10 14:10:26 +03002274 char *full_path;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002275 struct dfs_info3_param *referrals = NULL;
2276 unsigned int num_referrals = 0;
2277
2278 char *mount_data = mount_data_global;
2279
2280try_mount_again:
2281 full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282
2283 xid = GetXid();
2284
Jeff Layton7586b762008-12-01 18:41:49 -05002285 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2286 if (!volume_info) {
2287 rc = -ENOMEM;
2288 goto out;
2289 }
Steve French50c2f752007-07-13 00:33:32 +00002290
Jeff Layton7586b762008-12-01 18:41:49 -05002291 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002292 rc = -EINVAL;
2293 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 }
2295
Jeff Layton7586b762008-12-01 18:41:49 -05002296 if (volume_info->nullauth) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002297 cFYI(1, ("null user"));
Jeff Layton7586b762008-12-01 18:41:49 -05002298 volume_info->username = "";
2299 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 /* BB fixme parse for domain name here */
Jeff Layton7586b762008-12-01 18:41:49 -05002301 cFYI(1, ("Username: %s", volume_info->username));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002303 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002304 /* In userspace mount helper we can get user name from alternate
2305 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002306 rc = -EINVAL;
2307 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 }
2309
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
2311 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002312 if (volume_info->iocharset == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 cifs_sb->local_nls = load_nls_default();
2314 /* load_nls_default can not return null */
2315 } else {
Jeff Layton7586b762008-12-01 18:41:49 -05002316 cifs_sb->local_nls = load_nls(volume_info->iocharset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002317 if (cifs_sb->local_nls == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002318 cERROR(1, ("CIFS mount error: iocharset %s not found",
Jeff Layton7586b762008-12-01 18:41:49 -05002319 volume_info->iocharset));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002320 rc = -ELIBACC;
2321 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 }
2323 }
2324
Jeff Layton63c038c2008-12-01 18:41:46 -05002325 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002326 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002327 if (IS_ERR(srvTcp)) {
2328 rc = PTR_ERR(srvTcp);
2329 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 }
2331
Jeff Layton7586b762008-12-01 18:41:49 -05002332 pSesInfo = cifs_find_smb_ses(srvTcp, volume_info->username);
Jeff Layton14fbf502008-11-14 13:53:46 -05002333 if (pSesInfo) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002334 cFYI(1, ("Existing smb sess found (status=%d)",
2335 pSesInfo->status));
Jeff Layton14fbf502008-11-14 13:53:46 -05002336 /*
2337 * The existing SMB session already has a reference to srvTcp,
2338 * so we can put back the extra one we got before
2339 */
2340 cifs_put_tcp_session(srvTcp);
2341
Steve French88e7d702008-01-03 17:37:09 +00002342 down(&pSesInfo->sesSem);
Steve French3b795212008-11-13 19:45:32 +00002343 if (pSesInfo->need_reconnect) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002344 cFYI(1, ("Session needs reconnect"));
Jeff Layton1d9a8852007-12-31 01:37:11 +00002345 rc = cifs_setup_session(xid, pSesInfo,
2346 cifs_sb->local_nls);
Jeff Layton1d9a8852007-12-31 01:37:11 +00002347 }
Steve French88e7d702008-01-03 17:37:09 +00002348 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 } else if (!rc) {
Steve Frenchbf820672005-12-01 22:32:42 -08002350 cFYI(1, ("Existing smb sess not found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 pSesInfo = sesInfoAlloc();
Jeff Layton14fbf502008-11-14 13:53:46 -05002352 if (pSesInfo == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 rc = -ENOMEM;
Jeff Layton14fbf502008-11-14 13:53:46 -05002354 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 }
2356
Jeff Layton14fbf502008-11-14 13:53:46 -05002357 /* new SMB session uses our srvTcp ref */
2358 pSesInfo->server = srvTcp;
Jeff Layton63c038c2008-12-01 18:41:46 -05002359 if (srvTcp->addr.sockAddr6.sin6_family == AF_INET6)
Linus Torvalds0191b622008-12-28 12:49:40 -08002360 sprintf(pSesInfo->serverName, "%pI6",
2361 &srvTcp->addr.sockAddr6.sin6_addr);
Jeff Layton8ecaf672008-12-01 15:23:50 -05002362 else
Linus Torvalds0191b622008-12-28 12:49:40 -08002363 sprintf(pSesInfo->serverName, "%pI4",
2364 &srvTcp->addr.sockAddr.sin_addr.s_addr);
Jeff Layton14fbf502008-11-14 13:53:46 -05002365
2366 write_lock(&cifs_tcp_ses_lock);
2367 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2368 write_unlock(&cifs_tcp_ses_lock);
2369
Jeff Layton7586b762008-12-01 18:41:49 -05002370 /* volume_info->password freed at unmount */
2371 if (volume_info->password) {
Jeff Layton00e485b2008-12-05 20:41:21 -05002372 pSesInfo->password = kstrdup(volume_info->password,
2373 GFP_KERNEL);
2374 if (!pSesInfo->password) {
2375 rc = -ENOMEM;
2376 goto mount_fail_check;
2377 }
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002378 }
Jeff Layton7586b762008-12-01 18:41:49 -05002379 if (volume_info->username)
2380 strncpy(pSesInfo->userName, volume_info->username,
Jeff Layton14fbf502008-11-14 13:53:46 -05002381 MAX_USERNAME_SIZE);
Jeff Layton7586b762008-12-01 18:41:49 -05002382 if (volume_info->domainname) {
2383 int len = strlen(volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002384 pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2385 if (pSesInfo->domainName)
2386 strcpy(pSesInfo->domainName,
Jeff Layton7586b762008-12-01 18:41:49 -05002387 volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002388 }
Jeff Layton7586b762008-12-01 18:41:49 -05002389 pSesInfo->linux_uid = volume_info->linux_uid;
2390 pSesInfo->overrideSecFlg = volume_info->secFlg;
Jeff Layton14fbf502008-11-14 13:53:46 -05002391 down(&pSesInfo->sesSem);
2392
2393 /* BB FIXME need to pass vol->secFlgs BB */
2394 rc = cifs_setup_session(xid, pSesInfo,
2395 cifs_sb->local_nls);
2396 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397 }
Steve French50c2f752007-07-13 00:33:32 +00002398
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 /* search for existing tcon to this server share */
2400 if (!rc) {
Jeff Layton7586b762008-12-01 18:41:49 -05002401 setup_cifs_sb(volume_info, cifs_sb);
Steve French0ae0efa2005-10-10 10:57:19 -07002402
Jeff Layton7586b762008-12-01 18:41:49 -05002403 tcon = cifs_find_tcon(pSesInfo, volume_info->UNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 if (tcon) {
Steve Frenchbf820672005-12-01 22:32:42 -08002405 cFYI(1, ("Found match on UNC path"));
Jeff Laytonf1987b42008-11-15 11:12:47 -05002406 /* existing tcon already has a reference */
2407 cifs_put_smb_ses(pSesInfo);
Jeff Layton7586b762008-12-01 18:41:49 -05002408 if (tcon->seal != volume_info->seal)
Steve French95b1cb92008-05-15 16:44:38 +00002409 cERROR(1, ("transport encryption setting "
2410 "conflicts with existing tid"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 } else {
2412 tcon = tconInfoAlloc();
Steve French3b795212008-11-13 19:45:32 +00002413 if (tcon == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 rc = -ENOMEM;
Steve French3b795212008-11-13 19:45:32 +00002415 goto mount_fail_check;
2416 }
Jeff Layton00e485b2008-12-05 20:41:21 -05002417
Steve Frenchab3f9922008-11-17 16:03:00 +00002418 tcon->ses = pSesInfo;
Jeff Layton00e485b2008-12-05 20:41:21 -05002419 if (volume_info->password) {
2420 tcon->password = kstrdup(volume_info->password,
2421 GFP_KERNEL);
2422 if (!tcon->password) {
2423 rc = -ENOMEM;
2424 goto mount_fail_check;
2425 }
2426 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427
Jeff Layton7586b762008-12-01 18:41:49 -05002428 if ((strchr(volume_info->UNC + 3, '\\') == NULL)
2429 && (strchr(volume_info->UNC + 3, '/') == NULL)) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002430 cERROR(1, ("Missing share name"));
Steve French3b795212008-11-13 19:45:32 +00002431 rc = -ENODEV;
2432 goto mount_fail_check;
2433 } else {
2434 /* BB Do we need to wrap sesSem around
2435 * this TCon call and Unix SetFS as
2436 * we do on SessSetup and reconnect? */
Jeff Layton7586b762008-12-01 18:41:49 -05002437 rc = CIFSTCon(xid, pSesInfo, volume_info->UNC,
Steve French3b795212008-11-13 19:45:32 +00002438 tcon, cifs_sb->local_nls);
2439 cFYI(1, ("CIFS Tcon rc = %d", rc));
Jeff Layton7586b762008-12-01 18:41:49 -05002440 if (volume_info->nodfs) {
Steve French3b795212008-11-13 19:45:32 +00002441 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2442 cFYI(1, ("DFS disabled (%d)",
2443 tcon->Flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 }
2445 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002446 if (rc)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002447 goto remote_path_check;
Jeff Layton7586b762008-12-01 18:41:49 -05002448 tcon->seal = volume_info->seal;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002449 write_lock(&cifs_tcp_ses_lock);
2450 list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2451 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 }
Steve French3b795212008-11-13 19:45:32 +00002453
2454 /* we can have only one retry value for a connection
2455 to a share so for resources mounted more than once
2456 to the same server share the last value passed in
2457 for the retry flag is used */
Jeff Layton7586b762008-12-01 18:41:49 -05002458 tcon->retry = volume_info->retry;
2459 tcon->nocase = volume_info->nocase;
2460 tcon->local_lease = volume_info->local_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 }
Steve French4523cc32007-04-30 20:13:06 +00002462 if (pSesInfo) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2464 sb->s_maxbytes = (u64) 1 << 63;
2465 } else
2466 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2467 }
2468
Steve French8af18972007-02-14 04:42:51 +00002469 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 sb->s_time_gran = 100;
2471
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002472 if (rc)
2473 goto remote_path_check;
2474
Steve Frenchd82c2df2008-11-15 00:07:26 +00002475 cifs_sb->tcon = tcon;
Steve Frenchd82c2df2008-11-15 00:07:26 +00002476
2477 /* do not care if following two calls succeed - informational */
2478 if (!tcon->ipc) {
2479 CIFSSMBQFSDeviceInfo(xid, tcon);
2480 CIFSSMBQFSAttributeInfo(xid, tcon);
2481 }
2482
2483 /* tell server which Unix caps we support */
2484 if (tcon->ses->capabilities & CAP_UNIX)
2485 /* reset of caps checks mount to see if unix extensions
2486 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002487 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002488 else
2489 tcon->unix_ext = 0; /* server does not support them */
2490
2491 /* convert forward to back slashes in prepath here if needed */
2492 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2493 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2494
2495 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2496 cifs_sb->rsize = 1024 * 127;
2497 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2498 }
2499 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2500 cifs_sb->wsize = min(cifs_sb->wsize,
2501 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2502 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2503 cifs_sb->rsize = min(cifs_sb->rsize,
2504 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002506remote_path_check:
2507 /* check if a whole path (including prepath) is not remote */
2508 if (!rc && cifs_sb->prepathlen && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002509 /* build_path_to_root works only when we have a valid tcon */
2510 full_path = cifs_build_path_to_root(cifs_sb);
2511 if (full_path == NULL) {
2512 rc = -ENOMEM;
2513 goto mount_fail_check;
2514 }
2515 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002516 if (rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002517 kfree(full_path);
2518 goto mount_fail_check;
2519 }
2520 kfree(full_path);
2521 }
2522
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002523 /* get referral if needed */
2524 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00002525#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002526 /* convert forward to back slashes in prepath here if needed */
2527 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2528 convert_delimiter(cifs_sb->prepath,
2529 CIFS_DIR_SEP(cifs_sb));
2530 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2531 if (IS_ERR(full_path)) {
2532 rc = PTR_ERR(full_path);
2533 goto mount_fail_check;
2534 }
2535
2536 cFYI(1, ("Getting referral for: %s", full_path));
2537 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2538 cifs_sb->local_nls, &num_referrals, &referrals,
2539 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2540 if (!rc && num_referrals > 0) {
2541 char *fake_devname = NULL;
2542
2543 if (mount_data != mount_data_global)
2544 kfree(mount_data);
2545 mount_data = cifs_compose_mount_options(
2546 cifs_sb->mountdata, full_path + 1,
2547 referrals, &fake_devname);
2548 kfree(fake_devname);
2549 free_dfs_info_array(referrals, num_referrals);
2550
2551 if (tcon)
2552 cifs_put_tcon(tcon);
2553 else if (pSesInfo)
2554 cifs_put_smb_ses(pSesInfo);
2555
2556 cleanup_volume_info(&volume_info);
2557 FreeXid(xid);
2558 kfree(full_path);
2559 goto try_mount_again;
2560 }
Steve Frenchd036f502009-04-03 03:12:08 +00002561#else /* No DFS support, return error on mount */
2562 rc = -EOPNOTSUPP;
2563#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002564 }
2565
2566mount_fail_check:
2567 /* on error free sesinfo and tcon struct if needed */
2568 if (rc) {
2569 if (mount_data != mount_data_global)
2570 kfree(mount_data);
2571 /* If find_unc succeeded then rc == 0 so we can not end */
2572 /* up accidently freeing someone elses tcon struct */
2573 if (tcon)
2574 cifs_put_tcon(tcon);
2575 else if (pSesInfo)
2576 cifs_put_smb_ses(pSesInfo);
2577 else
2578 cifs_put_tcp_session(srvTcp);
2579 goto out;
2580 }
2581
Jeff Layton7586b762008-12-01 18:41:49 -05002582 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 (in which case it is not needed anymore) but when new sesion is created
2584 the password ptr is put in the new session structure (in which case the
2585 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002586out:
2587 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002588 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 FreeXid(xid);
2590 return rc;
2591}
2592
2593static int
2594CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Steve French7c7b25b2006-06-01 19:20:10 +00002595 char session_key[CIFS_SESS_KEY_SIZE],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 const struct nls_table *nls_codepage)
2597{
2598 struct smb_hdr *smb_buffer;
2599 struct smb_hdr *smb_buffer_response;
2600 SESSION_SETUP_ANDX *pSMB;
2601 SESSION_SETUP_ANDX *pSMBr;
2602 char *bcc_ptr;
2603 char *user;
2604 char *domain;
2605 int rc = 0;
2606 int remaining_words = 0;
2607 int bytes_returned = 0;
2608 int len;
2609 __u32 capabilities;
2610 __u16 count;
2611
Steve Frencheeac8042006-01-13 21:34:58 -08002612 cFYI(1, ("In sesssetup"));
Steve French4523cc32007-04-30 20:13:06 +00002613 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 return -EINVAL;
2615 user = ses->userName;
2616 domain = ses->domainName;
2617 smb_buffer = cifs_buf_get();
Steve French582d21e2008-05-13 04:54:12 +00002618
2619 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 return -ENOMEM;
Steve French582d21e2008-05-13 04:54:12 +00002621
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 smb_buffer_response = smb_buffer;
2623 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2624
2625 /* send SMBsessionSetup here */
2626 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2627 NULL /* no tCon exists yet */ , 13 /* wct */ );
2628
Steve French1982c342005-08-17 12:38:22 -07002629 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 pSMB->req_no_secext.AndXCommand = 0xFF;
2631 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2632 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2633
Steve French50c2f752007-07-13 00:33:32 +00002634 if (ses->server->secMode &
2635 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2637
2638 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2639 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2640 if (ses->capabilities & CAP_UNICODE) {
2641 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2642 capabilities |= CAP_UNICODE;
2643 }
2644 if (ses->capabilities & CAP_STATUS32) {
2645 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2646 capabilities |= CAP_STATUS32;
2647 }
2648 if (ses->capabilities & CAP_DFS) {
2649 smb_buffer->Flags2 |= SMBFLG2_DFS;
2650 capabilities |= CAP_DFS;
2651 }
2652 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2653
Steve French50c2f752007-07-13 00:33:32 +00002654 pSMB->req_no_secext.CaseInsensitivePasswordLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002655 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656
2657 pSMB->req_no_secext.CaseSensitivePasswordLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002658 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 bcc_ptr = pByteArea(smb_buffer);
Steve French7c7b25b2006-06-01 19:20:10 +00002660 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2661 bcc_ptr += CIFS_SESS_KEY_SIZE;
2662 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2663 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664
2665 if (ses->capabilities & CAP_UNICODE) {
2666 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2667 *bcc_ptr = 0;
2668 bcc_ptr++;
2669 }
Steve French4523cc32007-04-30 20:13:06 +00002670 if (user == NULL)
Steve French39798772006-05-31 22:40:51 +00002671 bytes_returned = 0; /* skip null user */
Steve French50c2f752007-07-13 00:33:32 +00002672 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 bytes_returned =
Steve French50c2f752007-07-13 00:33:32 +00002674 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 nls_codepage);
2676 /* convert number of 16 bit words to bytes */
2677 bcc_ptr += 2 * bytes_returned;
2678 bcc_ptr += 2; /* trailing null */
2679 if (domain == NULL)
2680 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002681 cifs_strtoUCS((__le16 *) bcc_ptr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 "CIFS_LINUX_DOM", 32, nls_codepage);
2683 else
2684 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002685 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 nls_codepage);
2687 bcc_ptr += 2 * bytes_returned;
2688 bcc_ptr += 2;
2689 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002690 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 32, nls_codepage);
2692 bcc_ptr += 2 * bytes_returned;
2693 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002694 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 32, nls_codepage);
2696 bcc_ptr += 2 * bytes_returned;
2697 bcc_ptr += 2;
2698 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002699 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 64, nls_codepage);
2701 bcc_ptr += 2 * bytes_returned;
2702 bcc_ptr += 2;
2703 } else {
Steve French50c2f752007-07-13 00:33:32 +00002704 if (user != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 strncpy(bcc_ptr, user, 200);
2706 bcc_ptr += strnlen(user, 200);
2707 }
2708 *bcc_ptr = 0;
2709 bcc_ptr++;
2710 if (domain == NULL) {
2711 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2712 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2713 } else {
2714 strncpy(bcc_ptr, domain, 64);
2715 bcc_ptr += strnlen(domain, 64);
2716 *bcc_ptr = 0;
2717 bcc_ptr++;
2718 }
2719 strcpy(bcc_ptr, "Linux version ");
2720 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002721 strcpy(bcc_ptr, utsname()->release);
2722 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2724 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2725 }
2726 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2727 smb_buffer->smb_buf_length += count;
2728 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2729
2730 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00002731 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732 if (rc) {
2733/* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2734 } else if ((smb_buffer_response->WordCount == 3)
2735 || (smb_buffer_response->WordCount == 4)) {
2736 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2737 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2738 if (action & GUEST_LOGIN)
Steve French61e74802008-12-03 00:57:54 +00002739 cFYI(1, ("Guest login")); /* BB mark SesInfo struct? */
Steve French50c2f752007-07-13 00:33:32 +00002740 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2741 (little endian) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 cFYI(1, ("UID = %d ", ses->Suid));
Steve French50c2f752007-07-13 00:33:32 +00002743 /* response can have either 3 or 4 word count - Samba sends 3 */
2744 bcc_ptr = pByteArea(smb_buffer_response);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 if ((pSMBr->resp.hdr.WordCount == 3)
2746 || ((pSMBr->resp.hdr.WordCount == 4)
2747 && (blob_len < pSMBr->resp.ByteCount))) {
2748 if (pSMBr->resp.hdr.WordCount == 4)
2749 bcc_ptr += blob_len;
2750
2751 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2752 if ((long) (bcc_ptr) % 2) {
2753 remaining_words =
Steve French50c2f752007-07-13 00:33:32 +00002754 (BCC(smb_buffer_response) - 1) / 2;
2755 /* Unicode strings must be word
2756 aligned */
2757 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 } else {
2759 remaining_words =
2760 BCC(smb_buffer_response) / 2;
2761 }
2762 len =
2763 UniStrnlen((wchar_t *) bcc_ptr,
2764 remaining_words - 1);
2765/* We look for obvious messed up bcc or strings in response so we do not go off
2766 the end since (at least) WIN2K and Windows XP have a major bug in not null
2767 terminating last Unicode string in response */
Wei Yongjun74496d32009-03-31 16:28:36 +08002768 kfree(ses->serverOS);
Steve French50c2f752007-07-13 00:33:32 +00002769 ses->serverOS = kzalloc(2 * (len + 1),
2770 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002771 if (ses->serverOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002772 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 cifs_strfromUCS_le(ses->serverOS,
Steve French50c2f752007-07-13 00:33:32 +00002774 (__le16 *)bcc_ptr,
2775 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 bcc_ptr += 2 * (len + 1);
2777 remaining_words -= len + 1;
2778 ses->serverOS[2 * len] = 0;
2779 ses->serverOS[1 + (2 * len)] = 0;
2780 if (remaining_words > 0) {
2781 len = UniStrnlen((wchar_t *)bcc_ptr,
2782 remaining_words-1);
Steve Frenchcd49b492006-06-26 04:22:36 +00002783 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00002784 ses->serverNOS = kzalloc(2 * (len + 1),
2785 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002786 if (ses->serverNOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002787 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 cifs_strfromUCS_le(ses->serverNOS,
Steve French50c2f752007-07-13 00:33:32 +00002789 (__le16 *)bcc_ptr,
2790 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 bcc_ptr += 2 * (len + 1);
2792 ses->serverNOS[2 * len] = 0;
2793 ses->serverNOS[1 + (2 * len)] = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002794 if (strncmp(ses->serverNOS,
Steve French50c2f752007-07-13 00:33:32 +00002795 "NT LAN Manager 4", 16) == 0) {
Steve French467a8f82007-06-27 22:41:32 +00002796 cFYI(1, ("NT4 server"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 ses->flags |= CIFS_SES_NT4;
2798 }
2799 remaining_words -= len + 1;
2800 if (remaining_words > 0) {
Steve French433dc242005-04-28 22:41:08 -07002801 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Steve French50c2f752007-07-13 00:33:32 +00002802 /* last string is not always null terminated
2803 (for e.g. for Windows XP & 2000) */
Wei Yongjun74496d32009-03-31 16:28:36 +08002804 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 ses->serverDomain =
Steve French50c2f752007-07-13 00:33:32 +00002806 kzalloc(2*(len+1),
2807 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002808 if (ses->serverDomain == NULL)
Steve French433dc242005-04-28 22:41:08 -07002809 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 cifs_strfromUCS_le(ses->serverDomain,
Steve French50c2f752007-07-13 00:33:32 +00002811 (__le16 *)bcc_ptr,
2812 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813 bcc_ptr += 2 * (len + 1);
2814 ses->serverDomain[2*len] = 0;
2815 ses->serverDomain[1+(2*len)] = 0;
Steve French50c2f752007-07-13 00:33:32 +00002816 } else { /* else no more room so create
2817 dummy domain string */
Wei Yongjun74496d32009-03-31 16:28:36 +08002818 kfree(ses->serverDomain);
Steve French50c2f752007-07-13 00:33:32 +00002819 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002820 kzalloc(2, GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00002821 }
Steve French50c2f752007-07-13 00:33:32 +00002822 } else { /* no room so create dummy domain
2823 and NOS string */
2824
Steve French433dc242005-04-28 22:41:08 -07002825 /* if these kcallocs fail not much we
2826 can do, but better to not fail the
2827 sesssetup itself */
Steve Frenchcd49b492006-06-26 04:22:36 +00002828 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002830 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00002831 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002833 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 }
2835 } else { /* ASCII */
2836 len = strnlen(bcc_ptr, 1024);
2837 if (((long) bcc_ptr + len) - (long)
2838 pByteArea(smb_buffer_response)
2839 <= BCC(smb_buffer_response)) {
Steve Frenchcd49b492006-06-26 04:22:36 +00002840 kfree(ses->serverOS);
Steve French50c2f752007-07-13 00:33:32 +00002841 ses->serverOS = kzalloc(len + 1,
2842 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002843 if (ses->serverOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002844 goto sesssetup_nomem;
Steve French50c2f752007-07-13 00:33:32 +00002845 strncpy(ses->serverOS, bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846
2847 bcc_ptr += len;
Steve French50c2f752007-07-13 00:33:32 +00002848 /* null terminate the string */
2849 bcc_ptr[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 bcc_ptr++;
2851
2852 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002853 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00002854 ses->serverNOS = kzalloc(len + 1,
2855 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002856 if (ses->serverNOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002857 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 strncpy(ses->serverNOS, bcc_ptr, len);
2859 bcc_ptr += len;
2860 bcc_ptr[0] = 0;
2861 bcc_ptr++;
2862
2863 len = strnlen(bcc_ptr, 1024);
Wei Yongjun74496d32009-03-31 16:28:36 +08002864 kfree(ses->serverDomain);
Steve French50c2f752007-07-13 00:33:32 +00002865 ses->serverDomain = kzalloc(len + 1,
2866 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002867 if (ses->serverDomain == NULL)
Steve French433dc242005-04-28 22:41:08 -07002868 goto sesssetup_nomem;
Steve French50c2f752007-07-13 00:33:32 +00002869 strncpy(ses->serverDomain, bcc_ptr,
2870 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 bcc_ptr += len;
2872 bcc_ptr[0] = 0;
2873 bcc_ptr++;
2874 } else
2875 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00002876 ("Variable field of length %d "
2877 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 len));
2879 }
2880 } else {
Steve French61e74802008-12-03 00:57:54 +00002881 cERROR(1, ("Security Blob Length extends beyond "
Steve French50c2f752007-07-13 00:33:32 +00002882 "end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 }
2884 } else {
Steve French61e74802008-12-03 00:57:54 +00002885 cERROR(1, ("Invalid Word count %d: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 smb_buffer_response->WordCount));
2887 rc = -EIO;
2888 }
Steve French433dc242005-04-28 22:41:08 -07002889sesssetup_nomem: /* do not return an error on nomem for the info strings,
2890 since that could make reconnection harder, and
2891 reconnection might be needed to free memory */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002892 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893
2894 return rc;
2895}
2896
2897static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
Steve French4b18f2a2008-04-29 00:06:05 +00002899 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 const struct nls_table *nls_codepage)
2901{
2902 struct smb_hdr *smb_buffer;
2903 struct smb_hdr *smb_buffer_response;
2904 SESSION_SETUP_ANDX *pSMB;
2905 SESSION_SETUP_ANDX *pSMBr;
2906 char *bcc_ptr;
2907 char *domain;
2908 int rc = 0;
2909 int remaining_words = 0;
2910 int bytes_returned = 0;
2911 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002912 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913 PNEGOTIATE_MESSAGE SecurityBlob;
2914 PCHALLENGE_MESSAGE SecurityBlob2;
2915 __u32 negotiate_flags, capabilities;
2916 __u16 count;
2917
Steve French12b3b8f2006-02-09 21:12:47 +00002918 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002919 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 return -EINVAL;
2921 domain = ses->domainName;
Steve French4b18f2a2008-04-29 00:06:05 +00002922 *pNTLMv2_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 smb_buffer = cifs_buf_get();
2924 if (smb_buffer == NULL) {
2925 return -ENOMEM;
2926 }
2927 smb_buffer_response = smb_buffer;
2928 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2929 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2930
2931 /* send SMBsessionSetup here */
2932 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2933 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002934
2935 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2937 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2938
2939 pSMB->req.AndXCommand = 0xFF;
2940 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2941 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2942
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002943 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2945
2946 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2947 CAP_EXTENDED_SECURITY;
2948 if (ses->capabilities & CAP_UNICODE) {
2949 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2950 capabilities |= CAP_UNICODE;
2951 }
2952 if (ses->capabilities & CAP_STATUS32) {
2953 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2954 capabilities |= CAP_STATUS32;
2955 }
2956 if (ses->capabilities & CAP_DFS) {
2957 smb_buffer->Flags2 |= SMBFLG2_DFS;
2958 capabilities |= CAP_DFS;
2959 }
2960 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2961
2962 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2963 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2964 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2965 SecurityBlob->MessageType = NtLmNegotiate;
2966 negotiate_flags =
2967 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
Steve French12b3b8f2006-02-09 21:12:47 +00002968 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2969 NTLMSSP_NEGOTIATE_56 |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002971 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002973/* if (ntlmv2_support)
Steve French39798772006-05-31 22:40:51 +00002974 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 /* setup pointers to domain name and workstation name */
2976 bcc_ptr += SecurityBlobLength;
2977
2978 SecurityBlob->WorkstationName.Buffer = 0;
2979 SecurityBlob->WorkstationName.Length = 0;
2980 SecurityBlob->WorkstationName.MaximumLength = 0;
2981
Steve French12b3b8f2006-02-09 21:12:47 +00002982 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2983 along with username on auth request (ie the response to challenge) */
2984 SecurityBlob->DomainName.Buffer = 0;
2985 SecurityBlob->DomainName.Length = 0;
2986 SecurityBlob->DomainName.MaximumLength = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 if (ses->capabilities & CAP_UNICODE) {
2988 if ((long) bcc_ptr % 2) {
2989 *bcc_ptr = 0;
2990 bcc_ptr++;
2991 }
2992
2993 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002994 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 32, nls_codepage);
2996 bcc_ptr += 2 * bytes_returned;
2997 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002998 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999 nls_codepage);
3000 bcc_ptr += 2 * bytes_returned;
3001 bcc_ptr += 2; /* null terminate Linux version */
3002 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003003 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 64, nls_codepage);
3005 bcc_ptr += 2 * bytes_returned;
3006 *(bcc_ptr + 1) = 0;
3007 *(bcc_ptr + 2) = 0;
3008 bcc_ptr += 2; /* null terminate network opsys string */
3009 *(bcc_ptr + 1) = 0;
3010 *(bcc_ptr + 2) = 0;
3011 bcc_ptr += 2; /* null domain */
3012 } else { /* ASCII */
3013 strcpy(bcc_ptr, "Linux version ");
3014 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003015 strcpy(bcc_ptr, utsname()->release);
3016 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3018 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3019 bcc_ptr++; /* empty domain field */
3020 *bcc_ptr = 0;
3021 }
3022 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3023 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3024 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3025 smb_buffer->smb_buf_length += count;
3026 pSMB->req.ByteCount = cpu_to_le16(count);
3027
3028 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00003029 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030
3031 if (smb_buffer_response->Status.CifsError ==
3032 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
3033 rc = 0;
3034
3035 if (rc) {
3036/* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
3037 } else if ((smb_buffer_response->WordCount == 3)
3038 || (smb_buffer_response->WordCount == 4)) {
3039 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3040 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3041
3042 if (action & GUEST_LOGIN)
Steve French61e74802008-12-03 00:57:54 +00003043 cFYI(1, ("Guest login"));
Steve French50c2f752007-07-13 00:33:32 +00003044 /* Do we want to set anything in SesInfo struct when guest login? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045
Steve French50c2f752007-07-13 00:33:32 +00003046 bcc_ptr = pByteArea(smb_buffer_response);
3047 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048
3049 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
3050 if (SecurityBlob2->MessageType != NtLmChallenge) {
Steve French61e74802008-12-03 00:57:54 +00003051 cFYI(1, ("Unexpected NTLMSSP message type received %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 SecurityBlob2->MessageType));
3053 } else if (ses) {
Steve French50c2f752007-07-13 00:33:32 +00003054 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
Steve French12b3b8f2006-02-09 21:12:47 +00003055 cFYI(1, ("UID = %d", ses->Suid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 if ((pSMBr->resp.hdr.WordCount == 3)
3057 || ((pSMBr->resp.hdr.WordCount == 4)
3058 && (blob_len <
3059 pSMBr->resp.ByteCount))) {
3060
3061 if (pSMBr->resp.hdr.WordCount == 4) {
3062 bcc_ptr += blob_len;
Steve French12b3b8f2006-02-09 21:12:47 +00003063 cFYI(1, ("Security Blob Length %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 blob_len));
3065 }
3066
Steve French12b3b8f2006-02-09 21:12:47 +00003067 cFYI(1, ("NTLMSSP Challenge rcvd"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068
3069 memcpy(ses->server->cryptKey,
3070 SecurityBlob2->Challenge,
3071 CIFS_CRYPTO_KEY_SIZE);
Steve French50c2f752007-07-13 00:33:32 +00003072 if (SecurityBlob2->NegotiateFlags &
Steve French12b3b8f2006-02-09 21:12:47 +00003073 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
Steve French4b18f2a2008-04-29 00:06:05 +00003074 *pNTLMv2_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075
Steve French50c2f752007-07-13 00:33:32 +00003076 if ((SecurityBlob2->NegotiateFlags &
3077 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 || (sign_CIFS_PDUs > 1))
Steve French50c2f752007-07-13 00:33:32 +00003079 ses->server->secMode |=
3080 SECMODE_SIGN_REQUIRED;
3081 if ((SecurityBlob2->NegotiateFlags &
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
Steve French50c2f752007-07-13 00:33:32 +00003083 ses->server->secMode |=
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 SECMODE_SIGN_ENABLED;
3085
3086 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3087 if ((long) (bcc_ptr) % 2) {
3088 remaining_words =
3089 (BCC(smb_buffer_response)
3090 - 1) / 2;
Steve French50c2f752007-07-13 00:33:32 +00003091 /* Must word align unicode strings */
3092 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 } else {
3094 remaining_words =
3095 BCC
3096 (smb_buffer_response) / 2;
3097 }
3098 len =
3099 UniStrnlen((wchar_t *) bcc_ptr,
3100 remaining_words - 1);
3101/* We look for obvious messed up bcc or strings in response so we do not go off
3102 the end since (at least) WIN2K and Windows XP have a major bug in not null
3103 terminating last Unicode string in response */
Wei Yongjun74496d32009-03-31 16:28:36 +08003104 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003106 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003108 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109 bcc_ptr, len,
3110 nls_codepage);
3111 bcc_ptr += 2 * (len + 1);
3112 remaining_words -= len + 1;
3113 ses->serverOS[2 * len] = 0;
3114 ses->serverOS[1 + (2 * len)] = 0;
3115 if (remaining_words > 0) {
3116 len = UniStrnlen((wchar_t *)
3117 bcc_ptr,
3118 remaining_words
3119 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00003120 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003122 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 GFP_KERNEL);
3124 cifs_strfromUCS_le(ses->
3125 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003126 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003127 bcc_ptr,
3128 len,
3129 nls_codepage);
3130 bcc_ptr += 2 * (len + 1);
3131 ses->serverNOS[2 * len] = 0;
3132 ses->serverNOS[1 +
3133 (2 * len)] = 0;
3134 remaining_words -= len + 1;
3135 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00003136 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3137 /* last string not always null terminated
3138 (for e.g. for Windows XP & 2000) */
Steve Frenchcd49b492006-06-26 04:22:36 +00003139 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003141 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 (len +
3143 1),
3144 GFP_KERNEL);
3145 cifs_strfromUCS_le
Steve Frenche89dc922005-11-11 15:18:19 -08003146 (ses->serverDomain,
3147 (__le16 *)bcc_ptr,
3148 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149 bcc_ptr +=
3150 2 * (len + 1);
Steve Frenche89dc922005-11-11 15:18:19 -08003151 ses->serverDomain[2*len]
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152 = 0;
Steve Frenche89dc922005-11-11 15:18:19 -08003153 ses->serverDomain
3154 [1 + (2 * len)]
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 = 0;
3156 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00003157 else {
Steve Frenchcd49b492006-06-26 04:22:36 +00003158 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003160 kzalloc(2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161 GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00003162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 } else { /* no room so create dummy domain and NOS string */
Steve Frenchcd49b492006-06-26 04:22:36 +00003164 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003166 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00003167 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003169 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003170 }
3171 } else { /* ASCII */
3172 len = strnlen(bcc_ptr, 1024);
3173 if (((long) bcc_ptr + len) - (long)
3174 pByteArea(smb_buffer_response)
3175 <= BCC(smb_buffer_response)) {
Wei Yongjun74496d32009-03-31 16:28:36 +08003176 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003178 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179 GFP_KERNEL);
3180 strncpy(ses->serverOS,
3181 bcc_ptr, len);
3182
3183 bcc_ptr += len;
3184 bcc_ptr[0] = 0; /* null terminate string */
3185 bcc_ptr++;
3186
3187 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00003188 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003190 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 GFP_KERNEL);
3192 strncpy(ses->serverNOS, bcc_ptr, len);
3193 bcc_ptr += len;
3194 bcc_ptr[0] = 0;
3195 bcc_ptr++;
3196
3197 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00003198 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003200 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +00003202 strncpy(ses->serverDomain,
3203 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204 bcc_ptr += len;
3205 bcc_ptr[0] = 0;
3206 bcc_ptr++;
3207 } else
3208 cFYI(1,
Steve French63135e02007-07-17 17:34:02 +00003209 ("field of length %d "
3210 "extends beyond end of smb",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211 len));
3212 }
3213 } else {
Steve French50c2f752007-07-13 00:33:32 +00003214 cERROR(1, ("Security Blob Length extends beyond"
3215 " end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216 }
3217 } else {
3218 cERROR(1, ("No session structure passed in."));
3219 }
3220 } else {
Steve French61e74802008-12-03 00:57:54 +00003221 cERROR(1, ("Invalid Word count %d:",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222 smb_buffer_response->WordCount));
3223 rc = -EIO;
3224 }
3225
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003226 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227
3228 return rc;
3229}
3230static int
3231CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Steve French4b18f2a2008-04-29 00:06:05 +00003232 char *ntlm_session_key, bool ntlmv2_flag,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003233 const struct nls_table *nls_codepage)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234{
3235 struct smb_hdr *smb_buffer;
3236 struct smb_hdr *smb_buffer_response;
3237 SESSION_SETUP_ANDX *pSMB;
3238 SESSION_SETUP_ANDX *pSMBr;
3239 char *bcc_ptr;
3240 char *user;
3241 char *domain;
3242 int rc = 0;
3243 int remaining_words = 0;
3244 int bytes_returned = 0;
3245 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003246 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 PAUTHENTICATE_MESSAGE SecurityBlob;
3248 __u32 negotiate_flags, capabilities;
3249 __u16 count;
3250
3251 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003252 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253 return -EINVAL;
3254 user = ses->userName;
3255 domain = ses->domainName;
3256 smb_buffer = cifs_buf_get();
3257 if (smb_buffer == NULL) {
3258 return -ENOMEM;
3259 }
3260 smb_buffer_response = smb_buffer;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003261 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
3262 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263
3264 /* send SMBsessionSetup here */
3265 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
3266 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07003267
3268 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
3270 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
3271 pSMB->req.AndXCommand = 0xFF;
3272 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
3273 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
3274
3275 pSMB->req.hdr.Uid = ses->Suid;
3276
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003277 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3279
3280 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003281 CAP_EXTENDED_SECURITY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282 if (ses->capabilities & CAP_UNICODE) {
3283 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3284 capabilities |= CAP_UNICODE;
3285 }
3286 if (ses->capabilities & CAP_STATUS32) {
3287 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3288 capabilities |= CAP_STATUS32;
3289 }
3290 if (ses->capabilities & CAP_DFS) {
3291 smb_buffer->Flags2 |= SMBFLG2_DFS;
3292 capabilities |= CAP_DFS;
3293 }
3294 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3295
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003296 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3297 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3299 SecurityBlob->MessageType = NtLmAuthenticate;
3300 bcc_ptr += SecurityBlobLength;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003301 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3302 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3303 0x80000000 | NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003304 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003306 if (ntlmv2_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3308
3309/* setup pointers to domain name and workstation name */
3310
3311 SecurityBlob->WorkstationName.Buffer = 0;
3312 SecurityBlob->WorkstationName.Length = 0;
3313 SecurityBlob->WorkstationName.MaximumLength = 0;
3314 SecurityBlob->SessionKey.Length = 0;
3315 SecurityBlob->SessionKey.MaximumLength = 0;
3316 SecurityBlob->SessionKey.Buffer = 0;
3317
3318 SecurityBlob->LmChallengeResponse.Length = 0;
3319 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3320 SecurityBlob->LmChallengeResponse.Buffer = 0;
3321
3322 SecurityBlob->NtChallengeResponse.Length =
Steve French7c7b25b2006-06-01 19:20:10 +00003323 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 SecurityBlob->NtChallengeResponse.MaximumLength =
Steve French7c7b25b2006-06-01 19:20:10 +00003325 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3326 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327 SecurityBlob->NtChallengeResponse.Buffer =
3328 cpu_to_le32(SecurityBlobLength);
Steve French7c7b25b2006-06-01 19:20:10 +00003329 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3330 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331
3332 if (ses->capabilities & CAP_UNICODE) {
3333 if (domain == NULL) {
3334 SecurityBlob->DomainName.Buffer = 0;
3335 SecurityBlob->DomainName.Length = 0;
3336 SecurityBlob->DomainName.MaximumLength = 0;
3337 } else {
Steve French77159b42007-08-31 01:10:17 +00003338 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003339 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003340 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003342 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343 SecurityBlob->DomainName.Buffer =
3344 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003345 bcc_ptr += ln;
3346 SecurityBlobLength += ln;
3347 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003348 }
3349 if (user == NULL) {
3350 SecurityBlob->UserName.Buffer = 0;
3351 SecurityBlob->UserName.Length = 0;
3352 SecurityBlob->UserName.MaximumLength = 0;
3353 } else {
Steve French77159b42007-08-31 01:10:17 +00003354 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003356 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357 SecurityBlob->UserName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003358 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359 SecurityBlob->UserName.Buffer =
3360 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003361 bcc_ptr += ln;
3362 SecurityBlobLength += ln;
3363 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364 }
3365
Steve French63135e02007-07-17 17:34:02 +00003366 /* SecurityBlob->WorkstationName.Length =
3367 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003368 SecurityBlob->WorkstationName.Length *= 2;
Steve French63135e02007-07-17 17:34:02 +00003369 SecurityBlob->WorkstationName.MaximumLength =
3370 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3371 SecurityBlob->WorkstationName.Buffer =
3372 cpu_to_le32(SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373 bcc_ptr += SecurityBlob->WorkstationName.Length;
3374 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
Steve French63135e02007-07-17 17:34:02 +00003375 SecurityBlob->WorkstationName.Length =
3376 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377
3378 if ((long) bcc_ptr % 2) {
3379 *bcc_ptr = 0;
3380 bcc_ptr++;
3381 }
3382 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003383 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384 32, nls_codepage);
3385 bcc_ptr += 2 * bytes_returned;
3386 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003387 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388 nls_codepage);
3389 bcc_ptr += 2 * bytes_returned;
3390 bcc_ptr += 2; /* null term version string */
3391 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003392 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393 64, nls_codepage);
3394 bcc_ptr += 2 * bytes_returned;
3395 *(bcc_ptr + 1) = 0;
3396 *(bcc_ptr + 2) = 0;
3397 bcc_ptr += 2; /* null terminate network opsys string */
3398 *(bcc_ptr + 1) = 0;
3399 *(bcc_ptr + 2) = 0;
3400 bcc_ptr += 2; /* null domain */
3401 } else { /* ASCII */
3402 if (domain == NULL) {
3403 SecurityBlob->DomainName.Buffer = 0;
3404 SecurityBlob->DomainName.Length = 0;
3405 SecurityBlob->DomainName.MaximumLength = 0;
3406 } else {
Steve French77159b42007-08-31 01:10:17 +00003407 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3409 strncpy(bcc_ptr, domain, 63);
Steve French77159b42007-08-31 01:10:17 +00003410 ln = strnlen(domain, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003412 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413 SecurityBlob->DomainName.Buffer =
3414 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003415 bcc_ptr += ln;
3416 SecurityBlobLength += ln;
3417 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418 }
3419 if (user == NULL) {
3420 SecurityBlob->UserName.Buffer = 0;
3421 SecurityBlob->UserName.Length = 0;
3422 SecurityBlob->UserName.MaximumLength = 0;
3423 } else {
Steve French77159b42007-08-31 01:10:17 +00003424 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003425 strncpy(bcc_ptr, user, 63);
Steve French77159b42007-08-31 01:10:17 +00003426 ln = strnlen(user, 64);
3427 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428 SecurityBlob->UserName.Buffer =
Steve French77159b42007-08-31 01:10:17 +00003429 cpu_to_le32(SecurityBlobLength);
3430 bcc_ptr += ln;
3431 SecurityBlobLength += ln;
3432 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 }
3434 /* BB fill in our workstation name if known BB */
3435
3436 strcpy(bcc_ptr, "Linux version ");
3437 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003438 strcpy(bcc_ptr, utsname()->release);
3439 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3441 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3442 bcc_ptr++; /* null domain */
3443 *bcc_ptr = 0;
3444 }
3445 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3446 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3447 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3448 smb_buffer->smb_buf_length += count;
3449 pSMB->req.ByteCount = cpu_to_le16(count);
3450
3451 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00003452 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453 if (rc) {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003454/* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3455 } else if ((smb_buffer_response->WordCount == 3) ||
3456 (smb_buffer_response->WordCount == 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457 __u16 action = le16_to_cpu(pSMBr->resp.Action);
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003458 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 if (action & GUEST_LOGIN)
Steve French61e74802008-12-03 00:57:54 +00003460 cFYI(1, ("Guest login")); /* BB Should we set anything
Steve French50c2f752007-07-13 00:33:32 +00003461 in SesInfo struct ? */
3462/* if (SecurityBlob2->MessageType != NtLm??) {
3463 cFYI("Unexpected message type on auth response is %d"));
3464 } */
3465
Linus Torvalds1da177e2005-04-16 15:20:36 -07003466 if (ses) {
3467 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00003468 ("Check challenge UID %d vs auth response UID %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469 ses->Suid, smb_buffer_response->Uid));
Steve French50c2f752007-07-13 00:33:32 +00003470 /* UID left in wire format */
3471 ses->Suid = smb_buffer_response->Uid;
3472 bcc_ptr = pByteArea(smb_buffer_response);
3473 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 if ((pSMBr->resp.hdr.WordCount == 3)
3475 || ((pSMBr->resp.hdr.WordCount == 4)
3476 && (blob_len <
3477 pSMBr->resp.ByteCount))) {
3478 if (pSMBr->resp.hdr.WordCount == 4) {
3479 bcc_ptr +=
3480 blob_len;
3481 cFYI(1,
3482 ("Security Blob Length %d ",
3483 blob_len));
3484 }
3485
3486 cFYI(1,
3487 ("NTLMSSP response to Authenticate "));
3488
3489 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3490 if ((long) (bcc_ptr) % 2) {
3491 remaining_words =
3492 (BCC(smb_buffer_response)
3493 - 1) / 2;
3494 bcc_ptr++; /* Unicode strings must be word aligned */
3495 } else {
3496 remaining_words = BCC(smb_buffer_response) / 2;
3497 }
Steve French77159b42007-08-31 01:10:17 +00003498 len = UniStrnlen((wchar_t *) bcc_ptr,
3499 remaining_words - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500/* We look for obvious messed up bcc or strings in response so we do not go off
3501 the end since (at least) WIN2K and Windows XP have a major bug in not null
3502 terminating last Unicode string in response */
Wei Yongjun74496d32009-03-31 16:28:36 +08003503 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003505 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003507 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508 bcc_ptr, len,
3509 nls_codepage);
3510 bcc_ptr += 2 * (len + 1);
3511 remaining_words -= len + 1;
3512 ses->serverOS[2 * len] = 0;
3513 ses->serverOS[1 + (2 * len)] = 0;
3514 if (remaining_words > 0) {
3515 len = UniStrnlen((wchar_t *)
3516 bcc_ptr,
3517 remaining_words
3518 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00003519 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003521 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 GFP_KERNEL);
3523 cifs_strfromUCS_le(ses->
3524 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003525 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003526 bcc_ptr,
3527 len,
3528 nls_codepage);
3529 bcc_ptr += 2 * (len + 1);
3530 ses->serverNOS[2 * len] = 0;
3531 ses->serverNOS[1+(2*len)] = 0;
3532 remaining_words -= len + 1;
3533 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00003534 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003535 /* last string not always null terminated (e.g. for Windows XP & 2000) */
Wei Yongjun74496d32009-03-31 16:28:36 +08003536 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003537 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003538 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539 (len +
3540 1),
3541 GFP_KERNEL);
3542 cifs_strfromUCS_le
3543 (ses->
3544 serverDomain,
Steve Frenche89dc922005-11-11 15:18:19 -08003545 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 bcc_ptr, len,
3547 nls_codepage);
3548 bcc_ptr +=
3549 2 * (len + 1);
3550 ses->
3551 serverDomain[2
3552 * len]
3553 = 0;
3554 ses->
3555 serverDomain[1
3556 +
3557 (2
3558 *
3559 len)]
3560 = 0;
3561 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00003562 else {
Wei Yongjun74496d32009-03-31 16:28:36 +08003563 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003564 ses->serverDomain = kzalloc(2,GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00003565 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566 } else { /* no room so create dummy domain and NOS string */
Wei Yongjun74496d32009-03-31 16:28:36 +08003567 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003568 ses->serverDomain = kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00003569 kfree(ses->serverNOS);
Pekka Enberge915fc42005-09-06 15:18:35 -07003570 ses->serverNOS = kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571 }
3572 } else { /* ASCII */
3573 len = strnlen(bcc_ptr, 1024);
Steve French50c2f752007-07-13 00:33:32 +00003574 if (((long) bcc_ptr + len) -
3575 (long) pByteArea(smb_buffer_response)
Steve French63135e02007-07-17 17:34:02 +00003576 <= BCC(smb_buffer_response)) {
Wei Yongjun74496d32009-03-31 16:28:36 +08003577 kfree(ses->serverOS);
Steve French77159b42007-08-31 01:10:17 +00003578 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 strncpy(ses->serverOS,bcc_ptr, len);
3580
3581 bcc_ptr += len;
3582 bcc_ptr[0] = 0; /* null terminate the string */
3583 bcc_ptr++;
3584
3585 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00003586 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00003587 ses->serverNOS = kzalloc(len+1,
3588 GFP_KERNEL);
Steve French63135e02007-07-17 17:34:02 +00003589 strncpy(ses->serverNOS,
3590 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591 bcc_ptr += len;
3592 bcc_ptr[0] = 0;
3593 bcc_ptr++;
3594
3595 len = strnlen(bcc_ptr, 1024);
Wei Yongjun74496d32009-03-31 16:28:36 +08003596 kfree(ses->serverDomain);
Steve French63135e02007-07-17 17:34:02 +00003597 ses->serverDomain =
3598 kzalloc(len+1,
3599 GFP_KERNEL);
3600 strncpy(ses->serverDomain,
3601 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003602 bcc_ptr += len;
3603 bcc_ptr[0] = 0;
3604 bcc_ptr++;
3605 } else
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003606 cFYI(1, ("field of length %d "
Steve French63135e02007-07-17 17:34:02 +00003607 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 len));
3609 }
3610 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003611 cERROR(1, ("Security Blob extends beyond end "
Steve French63135e02007-07-17 17:34:02 +00003612 "of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003613 }
3614 } else {
3615 cERROR(1, ("No session structure passed in."));
3616 }
3617 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003618 cERROR(1, ("Invalid Word count %d: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 smb_buffer_response->WordCount));
3620 rc = -EIO;
3621 }
3622
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003623 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624
3625 return rc;
3626}
3627
3628int
3629CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3630 const char *tree, struct cifsTconInfo *tcon,
3631 const struct nls_table *nls_codepage)
3632{
3633 struct smb_hdr *smb_buffer;
3634 struct smb_hdr *smb_buffer_response;
3635 TCONX_REQ *pSMB;
3636 TCONX_RSP *pSMBr;
3637 unsigned char *bcc_ptr;
3638 int rc = 0;
3639 int length;
3640 __u16 count;
3641
3642 if (ses == NULL)
3643 return -EIO;
3644
3645 smb_buffer = cifs_buf_get();
3646 if (smb_buffer == NULL) {
3647 return -ENOMEM;
3648 }
3649 smb_buffer_response = smb_buffer;
3650
3651 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3652 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003653
3654 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003655 smb_buffer->Uid = ses->Suid;
3656 pSMB = (TCONX_REQ *) smb_buffer;
3657 pSMBr = (TCONX_RSP *) smb_buffer_response;
3658
3659 pSMB->AndXCommand = 0xFF;
3660 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003661 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003662 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08003663 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003664 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003665 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003666 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003667 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00003668 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003669 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3670 specified as required (when that support is added to
3671 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003672 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003673 by Samba (not sure whether other servers allow
3674 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003675#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French50c2f752007-07-13 00:33:32 +00003676 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003677 (ses->server->secType == LANMAN))
3678 calc_lanman_hash(tcon->password, ses->server->cryptKey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003679 ses->server->secMode &
3680 SECMODE_PW_ENCRYPT ? true : false,
3681 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003682 else
3683#endif /* CIFS_WEAK_PW_HASH */
Jeff Layton00e485b2008-12-05 20:41:21 -05003684 SMBNTencrypt(tcon->password, ses->server->cryptKey,
Steve Frencheeac8042006-01-13 21:34:58 -08003685 bcc_ptr);
3686
Steve French7c7b25b2006-06-01 19:20:10 +00003687 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003688 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003689 /* must align unicode strings */
3690 *bcc_ptr = 0; /* null byte password */
3691 bcc_ptr++;
3692 }
Steve Frencheeac8042006-01-13 21:34:58 -08003693 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003694
Steve French50c2f752007-07-13 00:33:32 +00003695 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003696 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003697 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3698
3699 if (ses->capabilities & CAP_STATUS32) {
3700 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3701 }
3702 if (ses->capabilities & CAP_DFS) {
3703 smb_buffer->Flags2 |= SMBFLG2_DFS;
3704 }
3705 if (ses->capabilities & CAP_UNICODE) {
3706 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3707 length =
Steve French50c2f752007-07-13 00:33:32 +00003708 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3709 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003710 (/* server len*/ + 256 /* share len */), nls_codepage);
3711 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003712 bcc_ptr += 2; /* skip trailing null */
3713 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003714 strcpy(bcc_ptr, tree);
3715 bcc_ptr += strlen(tree) + 1;
3716 }
3717 strcpy(bcc_ptr, "?????");
3718 bcc_ptr += strlen("?????");
3719 bcc_ptr += 1;
3720 count = bcc_ptr - &pSMB->Password[0];
3721 pSMB->hdr.smb_buf_length += count;
3722 pSMB->ByteCount = cpu_to_le16(count);
3723
Steve French133672e2007-11-13 22:41:37 +00003724 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3725 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003726
3727 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3728 /* above now done in SendReceive */
3729 if ((rc == 0) && (tcon != NULL)) {
3730 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003731 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732 tcon->tid = smb_buffer_response->Tid;
3733 bcc_ptr = pByteArea(smb_buffer_response);
3734 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
Steve French50c2f752007-07-13 00:33:32 +00003735 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003736 if (length == 3) {
3737 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3738 (bcc_ptr[2] == 'C')) {
3739 cFYI(1, ("IPC connection"));
3740 tcon->ipc = 1;
3741 }
3742 } else if (length == 2) {
3743 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3744 /* the most common case */
3745 cFYI(1, ("disk share connection"));
3746 }
3747 }
Steve French50c2f752007-07-13 00:33:32 +00003748 bcc_ptr += length + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3750 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3751 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3752 if ((bcc_ptr + (2 * length)) -
3753 pByteArea(smb_buffer_response) <=
3754 BCC(smb_buffer_response)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08003755 kfree(tcon->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003756 tcon->nativeFileSystem =
Steve Frenchb363b332009-03-18 05:57:22 +00003757 kzalloc(2*(length + 1), GFP_KERNEL);
Steve French88f370a2007-09-15 03:01:17 +00003758 if (tcon->nativeFileSystem)
3759 cifs_strfromUCS_le(
3760 tcon->nativeFileSystem,
3761 (__le16 *) bcc_ptr,
3762 length, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003763 bcc_ptr += 2 * length;
3764 bcc_ptr[0] = 0; /* null terminate the string */
3765 bcc_ptr[1] = 0;
3766 bcc_ptr += 2;
3767 }
Steve French50c2f752007-07-13 00:33:32 +00003768 /* else do not bother copying these information fields*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003769 } else {
3770 length = strnlen(bcc_ptr, 1024);
3771 if ((bcc_ptr + length) -
3772 pByteArea(smb_buffer_response) <=
3773 BCC(smb_buffer_response)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08003774 kfree(tcon->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003775 tcon->nativeFileSystem =
Pekka Enberge915fc42005-09-06 15:18:35 -07003776 kzalloc(length + 1, GFP_KERNEL);
Steve French88f370a2007-09-15 03:01:17 +00003777 if (tcon->nativeFileSystem)
3778 strncpy(tcon->nativeFileSystem, bcc_ptr,
3779 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003780 }
Steve French50c2f752007-07-13 00:33:32 +00003781 /* else do not bother copying these information fields*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003782 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003783 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003784 (smb_buffer_response->WordCount == 7))
3785 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003786 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3787 else
3788 tcon->Flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003789 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3790 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003791 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792 ses->ipc_tid = smb_buffer_response->Tid;
3793 }
3794
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003795 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003796 return rc;
3797}
3798
3799int
3800cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3801{
3802 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00003803 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804
Jeff Laytonf1987b42008-11-15 11:12:47 -05003805 if (cifs_sb->tcon)
3806 cifs_put_tcon(cifs_sb->tcon);
Steve French50c2f752007-07-13 00:33:32 +00003807
Linus Torvalds1da177e2005-04-16 15:20:36 -07003808 cifs_sb->tcon = NULL;
Steve French2fe87f02006-09-21 07:02:52 +00003809 tmp = cifs_sb->prepath;
3810 cifs_sb->prepathlen = 0;
3811 cifs_sb->prepath = NULL;
3812 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003813
Steve French88e7d702008-01-03 17:37:09 +00003814 return rc;
Steve French50c2f752007-07-13 00:33:32 +00003815}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816
3817int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
Steve French50c2f752007-07-13 00:33:32 +00003818 struct nls_table *nls_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819{
3820 int rc = 0;
Steve French7c7b25b2006-06-01 19:20:10 +00003821 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
Steve French4b18f2a2008-04-29 00:06:05 +00003822 bool ntlmv2_flag = false;
Steve Frenchad009ac2005-04-28 22:41:05 -07003823 int first_time = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003824 struct TCP_Server_Info *server = pSesInfo->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003825
3826 /* what if server changes its buffer size after dropping the session? */
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003827 if (server->maxBuf == 0) /* no need to send on reconnect */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003828 rc = CIFSSMBNegotiate(xid, pSesInfo);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003829 if (rc == -EAGAIN) {
3830 /* retry only once on 1st time connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve French50c2f752007-07-13 00:33:32 +00003832 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833 rc = -EHOSTDOWN;
3834 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003835 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003836 spin_lock(&GlobalMid_Lock);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003837 if (server->tcpStatus != CifsExiting)
3838 server->tcpStatus = CifsGood;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839 else
3840 rc = -EHOSTDOWN;
3841 spin_unlock(&GlobalMid_Lock);
3842
3843 }
Steve Frenchad009ac2005-04-28 22:41:05 -07003844 first_time = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003845 }
Steve French26b994f2008-08-06 05:11:33 +00003846
3847 if (rc)
3848 goto ss_err_exit;
3849
3850 pSesInfo->flags = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003851 pSesInfo->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003852 if (linuxExtEnabled == 0)
3853 pSesInfo->capabilities &= (~CAP_UNIX);
Steve Frenchad009ac2005-04-28 22:41:05 -07003854 /* pSesInfo->sequence_number = 0;*/
Steve French26b994f2008-08-06 05:11:33 +00003855 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003856 server->secMode, server->capabilities, server->timeAdj));
3857
Steve French26b994f2008-08-06 05:11:33 +00003858 if (experimEnabled < 2)
3859 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
3860 else if (extended_security
3861 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003862 && (server->secType == NTLMSSP)) {
Steve French26b994f2008-08-06 05:11:33 +00003863 rc = -EOPNOTSUPP;
3864 } else if (extended_security
3865 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003866 && (server->secType == RawNTLMSSP)) {
Steve French26b994f2008-08-06 05:11:33 +00003867 cFYI(1, ("NTLMSSP sesssetup"));
3868 rc = CIFSNTLMSSPNegotiateSessSetup(xid, pSesInfo, &ntlmv2_flag,
3869 nls_info);
3870 if (!rc) {
3871 if (ntlmv2_flag) {
3872 char *v2_response;
3873 cFYI(1, ("more secure NTLM ver2 hash"));
3874 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3875 nls_info)) {
3876 rc = -ENOMEM;
3877 goto ss_err_exit;
3878 } else
3879 v2_response = kmalloc(16 + 64 /* blob*/,
3880 GFP_KERNEL);
3881 if (v2_response) {
3882 CalcNTLMv2_response(pSesInfo,
3883 v2_response);
3884 /* if (first_time)
3885 cifs_calculate_ntlmv2_mac_key */
3886 kfree(v2_response);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003887 /* BB Put dummy sig in SessSetup PDU? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003888 } else {
Steve French26b994f2008-08-06 05:11:33 +00003889 rc = -ENOMEM;
3890 goto ss_err_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003891 }
Steve French26b994f2008-08-06 05:11:33 +00003892
3893 } else {
3894 SMBNTencrypt(pSesInfo->password,
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003895 server->cryptKey,
Steve French26b994f2008-08-06 05:11:33 +00003896 ntlm_session_key);
3897
3898 if (first_time)
3899 cifs_calculate_mac_key(
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003900 &server->mac_signing_key,
Steve French26b994f2008-08-06 05:11:33 +00003901 ntlm_session_key,
3902 pSesInfo->password);
3903 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003904 /* for better security the weaker lanman hash not sent
3905 in AuthSessSetup so we no longer calculate it */
3906
Steve French26b994f2008-08-06 05:11:33 +00003907 rc = CIFSNTLMSSPAuthSessSetup(xid, pSesInfo,
3908 ntlm_session_key,
3909 ntlmv2_flag,
3910 nls_info);
3911 }
3912 } else { /* old style NTLM 0.12 session setup */
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003913 SMBNTencrypt(pSesInfo->password, server->cryptKey,
Steve French26b994f2008-08-06 05:11:33 +00003914 ntlm_session_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003915
Steve French26b994f2008-08-06 05:11:33 +00003916 if (first_time)
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003917 cifs_calculate_mac_key(&server->mac_signing_key,
3918 ntlm_session_key,
3919 pSesInfo->password);
Steve Frenchad009ac2005-04-28 22:41:05 -07003920
Steve French26b994f2008-08-06 05:11:33 +00003921 rc = CIFSSessSetup(xid, pSesInfo, ntlm_session_key, nls_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922 }
Steve French26b994f2008-08-06 05:11:33 +00003923 if (rc) {
3924 cERROR(1, ("Send error in SessSetup = %d", rc));
3925 } else {
3926 cFYI(1, ("CIFS Session Established successfully"));
Jeff Layton469ee612008-10-16 18:46:39 +00003927 spin_lock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003928 pSesInfo->status = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003929 pSesInfo->need_reconnect = false;
Jeff Layton469ee612008-10-16 18:46:39 +00003930 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003931 }
3932
Linus Torvalds1da177e2005-04-16 15:20:36 -07003933ss_err_exit:
3934 return rc;
3935}
3936