blob: 39f5362e2cb5ff183932098421bbcfebe4395c68 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve Frenchd185cda2009-04-30 17:45:10 +00004 * Copyright (C) International Business Machines Corp., 2002,2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/pagemap.h>
27#include <linux/ctype.h>
28#include <linux/utsname.h>
29#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070030#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070031#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000032#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070033#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080034#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040035#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
37#include <asm/processor.h>
Steve French0e2beda2009-01-30 21:24:41 +000038#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "cifspdu.h"
40#include "cifsglob.h"
41#include "cifsproto.h"
42#include "cifs_unicode.h"
43#include "cifs_debug.h"
44#include "cifs_fs_sb.h"
45#include "ntlmssp.h"
46#include "nterr.h"
47#include "rfc1002pdu.h"
Steve Frencha2653eb2005-11-10 15:33:38 -080048#include "cn_cifs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#define CIFS_PORT 445
51#define RFC1001_PORT 139
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
54 unsigned char *p24);
55
56extern mempool_t *cifs_req_poolp;
57
58struct smb_vol {
59 char *username;
60 char *password;
61 char *domainname;
62 char *UNC;
63 char *UNCip;
Steve French95b1cb92008-05-15 16:44:38 +000064 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 char *iocharset; /* local code page for mapping to and from Unicode */
66 char source_rfc1001_name[16]; /* netbios name of client */
Steve Frencha10faeb22005-08-22 21:38:31 -070067 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 uid_t linux_uid;
69 gid_t linux_gid;
70 mode_t file_mode;
71 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000072 unsigned secFlg;
Steve French4b18f2a2008-04-29 00:06:05 +000073 bool rw:1;
74 bool retry:1;
75 bool intr:1;
76 bool setuids:1;
77 bool override_uid:1;
78 bool override_gid:1;
Jeff Laytond0a9c072008-05-12 22:23:49 +000079 bool dynperm:1;
Steve French4b18f2a2008-04-29 00:06:05 +000080 bool noperm:1;
81 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool cifs_acl:1;
83 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool direct_io:1;
Steve French95b1cb92008-05-15 16:44:38 +000086 bool remap:1; /* set to remap seven reserved chars in filenames */
87 bool posix_paths:1; /* unset to not ask for posix pathnames. */
Steve French4b18f2a2008-04-29 00:06:05 +000088 bool no_linux_ext:1;
89 bool sfu_emul:1;
Steve French95b1cb92008-05-15 16:44:38 +000090 bool nullauth:1; /* attempt to authenticate with null user */
91 bool nocase:1; /* request case insensitive filenames */
92 bool nobrl:1; /* disable sending byte range locks to srv */
Steve French13a6e422008-12-02 17:24:33 +000093 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
Steve French95b1cb92008-05-15 16:44:38 +000094 bool seal:1; /* request transport encryption on share */
Steve French84210e92008-10-23 04:42:37 +000095 bool nodfs:1; /* Do not request DFS, even if available */
96 bool local_lease:1; /* check leases only on local system, not remote */
Steve Frenchedf1ae42008-10-29 00:47:57 +000097 bool noblocksnd:1;
98 bool noautotune:1;
Steve Frenchbe652442009-02-23 15:21:59 +000099 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 unsigned int rsize;
101 unsigned int wsize;
102 unsigned int sockopt;
103 unsigned short int port;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000104 char *prepath;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105};
106
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500107static int ipv4_connect(struct TCP_Server_Info *server);
Jeff Laytond5c56052008-12-01 18:42:33 -0500108static int ipv6_connect(struct TCP_Server_Info *server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Jeff Laytond5c56052008-12-01 18:42:33 -0500110/*
111 * cifs tcp session reconnection
112 *
113 * mark tcp session as reconnecting so temporarily locked
114 * mark all smb sessions as reconnecting for tcp session
115 * reconnect tcp session
116 * wake up waiters on reconnection? - (not needed currently)
117 */
Steve French2cd646a2006-09-28 19:43:08 +0000118static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119cifs_reconnect(struct TCP_Server_Info *server)
120{
121 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500122 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 struct cifsSesInfo *ses;
124 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000125 struct mid_q_entry *mid_entry;
Steve French50c2f752007-07-13 00:33:32 +0000126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000128 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000129 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 next time through the loop */
131 spin_unlock(&GlobalMid_Lock);
132 return rc;
133 } else
134 server->tcpStatus = CifsNeedReconnect;
135 spin_unlock(&GlobalMid_Lock);
136 server->maxBuf = 0;
137
Steve Frenche4eb2952005-04-28 22:41:09 -0700138 cFYI(1, ("Reconnecting tcp session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140 /* before reconnecting the tcp session, mark the smb session (uid)
141 and the tid bad so they are not used until reconnected */
Jeff Layton14fbf502008-11-14 13:53:46 -0500142 read_lock(&cifs_tcp_ses_lock);
143 list_for_each(tmp, &server->smb_ses_list) {
144 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
145 ses->need_reconnect = true;
146 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500147 list_for_each(tmp2, &ses->tcon_list) {
148 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
149 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500152 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 /* do not want to be sending data on a socket we are freeing */
Jeff Layton72ca5452008-12-01 07:09:36 -0500154 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000155 if (server->ssocket) {
Steve French467a8f82007-06-27 22:41:32 +0000156 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 server->ssocket->flags));
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800158 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000159 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000160 server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 server->ssocket->flags));
162 sock_release(server->ssocket);
163 server->ssocket = NULL;
164 }
165
166 spin_lock(&GlobalMid_Lock);
167 list_for_each(tmp, &server->pending_mid_q) {
168 mid_entry = list_entry(tmp, struct
169 mid_q_entry,
170 qhead);
Steve Frenchad8b15f2008-08-08 21:10:16 +0000171 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French09d1db52005-04-28 22:41:08 -0700172 /* Mark other intransit requests as needing
173 retry so we do not immediately mark the
174 session bad again (ie after we reconnect
175 below) as they timeout too */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000176 mid_entry->midState = MID_RETRY_NEEDED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 }
178 }
179 spin_unlock(&GlobalMid_Lock);
Jeff Layton72ca5452008-12-01 07:09:36 -0500180 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Jeff Layton469ee612008-10-16 18:46:39 +0000182 while ((server->tcpStatus != CifsExiting) &&
183 (server->tcpStatus != CifsGood)) {
Steve French6c3d8902006-07-31 22:46:20 +0000184 try_to_freeze();
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500185 if (server->addr.sockAddr6.sin6_family == AF_INET6)
Jeff Laytond5c56052008-12-01 18:42:33 -0500186 rc = ipv6_connect(server);
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500187 else
188 rc = ipv4_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000189 if (rc) {
190 cFYI(1, ("reconnect error %d", rc));
Steve French0cb766a2005-04-28 22:41:11 -0700191 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 } else {
193 atomic_inc(&tcpSesReconnectCount);
194 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000195 if (server->tcpStatus != CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 server->tcpStatus = CifsGood;
Steve Frenchad009ac2005-04-28 22:41:05 -0700197 server->sequence_number = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000198 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 /* atomic_set(&server->inFlight,0);*/
200 wake_up(&server->response_q);
201 }
202 }
203 return rc;
204}
205
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000206/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700207 return codes:
208 0 not a transact2, or all data present
209 >0 transact2 with that much data missing
210 -EINVAL = invalid transact2
211
212 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000213static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700214{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000215 struct smb_t2_rsp *pSMBt;
216 int total_data_size;
Steve Frenche4eb2952005-04-28 22:41:09 -0700217 int data_in_this_rsp;
218 int remaining;
219
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000220 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700221 return 0;
222
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000223 /* check for plausible wct, bcc and t2 data and parm sizes */
224 /* check for parm and data offset going beyond end of smb */
225 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Steve French467a8f82007-06-27 22:41:32 +0000226 cFYI(1, ("invalid transact2 word count"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700227 return -EINVAL;
228 }
229
230 pSMBt = (struct smb_t2_rsp *)pSMB;
231
232 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
233 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
234
235 remaining = total_data_size - data_in_this_rsp;
236
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000237 if (remaining == 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700238 return 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000239 else if (remaining < 0) {
Steve French467a8f82007-06-27 22:41:32 +0000240 cFYI(1, ("total data %d smaller than data in frame %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700241 total_data_size, data_in_this_rsp));
242 return -EINVAL;
243 } else {
Steve French467a8f82007-06-27 22:41:32 +0000244 cFYI(1, ("missing %d bytes from transact2, check next response",
Steve Frenche4eb2952005-04-28 22:41:09 -0700245 remaining));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000246 if (total_data_size > maxBufSize) {
247 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
248 total_data_size, maxBufSize));
249 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700250 }
251 return remaining;
252 }
253}
254
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000255static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700256{
257 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
258 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
259 int total_data_size;
260 int total_in_buf;
261 int remaining;
262 int total_in_buf2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000263 char *data_area_of_target;
264 char *data_area_of_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700265 __u16 byte_count;
266
267 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
268
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000269 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
Steve French63135e02007-07-17 17:34:02 +0000270 cFYI(1, ("total data size of primary and secondary t2 differ"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700271 }
272
273 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
274
275 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000276
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000277 if (remaining < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700278 return -EINVAL;
279
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000280 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700281 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000282
Steve Frenche4eb2952005-04-28 22:41:09 -0700283 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000284 if (remaining < total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000285 cFYI(1, ("transact2 2nd response contains too much data"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700286 }
287
288 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000289 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Steve Frenche4eb2952005-04-28 22:41:09 -0700290 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
291 /* validate target area */
292
293 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000294 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700295
296 data_area_of_target += total_in_buf;
297
298 /* copy second buffer into end of first buffer */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000299 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
Steve Frenche4eb2952005-04-28 22:41:09 -0700300 total_in_buf += total_in_buf2;
301 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
302 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
303 byte_count += total_in_buf2;
304 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
305
Steve French70ca7342005-09-22 16:32:06 -0700306 byte_count = pTargetSMB->smb_buf_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700307 byte_count += total_in_buf2;
308
309 /* BB also add check that we are not beyond maximum buffer size */
Steve French50c2f752007-07-13 00:33:32 +0000310
Steve French70ca7342005-09-22 16:32:06 -0700311 pTargetSMB->smb_buf_length = byte_count;
Steve Frenche4eb2952005-04-28 22:41:09 -0700312
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000313 if (remaining == total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000314 cFYI(1, ("found the last secondary response"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700315 return 0; /* we are done */
316 } else /* more responses to go */
317 return 1;
318
319}
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321static int
322cifs_demultiplex_thread(struct TCP_Server_Info *server)
323{
324 int length;
325 unsigned int pdu_length, total_read;
326 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700327 struct smb_hdr *bigbuf = NULL;
328 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 struct msghdr smb_msg;
330 struct kvec iov;
331 struct socket *csocket = server->ssocket;
332 struct list_head *tmp;
333 struct cifsSesInfo *ses;
334 struct task_struct *task_to_wake = NULL;
335 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700336 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000337 bool isLargeBuf = false;
338 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700339 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 current->flags |= PF_MEMALLOC;
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700342 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400343
344 length = atomic_inc_return(&tcpSesAllocCount);
345 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000346 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
347 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700349 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000350 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700351 if (try_to_freeze())
352 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700353 if (bigbuf == NULL) {
354 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000355 if (!bigbuf) {
356 cERROR(1, ("No memory for large SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700357 msleep(3000);
358 /* retry will check if exiting */
359 continue;
360 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000361 } else if (isLargeBuf) {
362 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000363 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700365
366 if (smallbuf == NULL) {
367 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000368 if (!smallbuf) {
369 cERROR(1, ("No memory for SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700370 msleep(1000);
371 /* retry will check if exiting */
372 continue;
373 }
374 /* beginning of smb buffer is cleared in our buf_get */
375 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000376 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700377
Steve French4b18f2a2008-04-29 00:06:05 +0000378 isLargeBuf = false;
379 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700380 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 iov.iov_base = smb_buffer;
382 iov.iov_len = 4;
383 smb_msg.msg_control = NULL;
384 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000385 pdu_length = 4; /* enough to get RFC1001 header */
386incomplete_rcv:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 length =
388 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000389 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Jeff Layton469ee612008-10-16 18:46:39 +0000391 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 break;
393 } else if (server->tcpStatus == CifsNeedReconnect) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000394 cFYI(1, ("Reconnect after server stopped responding"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 cifs_reconnect(server);
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000396 cFYI(1, ("call to reconnect done"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 csocket = server->ssocket;
398 continue;
399 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700400 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 allowing socket to clear and app threads to set
402 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000403 if (pdu_length < 4) {
404 iov.iov_base = (4 - pdu_length) +
405 (char *)smb_buffer;
406 iov.iov_len = pdu_length;
407 smb_msg.msg_control = NULL;
408 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000409 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000410 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000411 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 } else if (length <= 0) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000413 if (server->tcpStatus == CifsNew) {
414 cFYI(1, ("tcp session abend after SMBnegprot"));
Steve French09d1db52005-04-28 22:41:08 -0700415 /* some servers kill the TCP session rather than
416 returning an SMB negprot error, in which
417 case reconnecting here is not going to help,
418 and so simply return error to mount */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 break;
420 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000421 if (!try_to_freeze() && (length == -EINTR)) {
Steve French467a8f82007-06-27 22:41:32 +0000422 cFYI(1, ("cifsd thread killed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 break;
424 }
Steve French467a8f82007-06-27 22:41:32 +0000425 cFYI(1, ("Reconnect after unexpected peek error %d",
Steve French57337e42005-04-28 22:41:10 -0700426 length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 cifs_reconnect(server);
428 csocket = server->ssocket;
429 wake_up(&server->response_q);
430 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000431 } else if (length < pdu_length) {
432 cFYI(1, ("requested %d bytes but only got %d bytes",
433 pdu_length, length));
Steve Frenchf01d5e12007-08-30 21:13:31 +0000434 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000435 msleep(1);
436 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
Steve French67010fb2005-04-28 22:41:09 -0700438
Steve French70ca7342005-09-22 16:32:06 -0700439 /* The right amount was read from socket - 4 bytes */
440 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700441
Steve French70ca7342005-09-22 16:32:06 -0700442 /* the first byte big endian of the length field,
443 is actually not part of the length but the type
444 with the most common, zero, as regular data */
445 temp = *((char *) smb_buffer);
446
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000447 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700448 but we convert it here so it is always manipulated
449 as host byte order */
Harvey Harrison5ca33c62008-07-23 17:45:58 -0700450 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
Steve French70ca7342005-09-22 16:32:06 -0700451 smb_buffer->smb_buf_length = pdu_length;
Steve French46810cb2005-04-28 22:41:09 -0700452
Steve French467a8f82007-06-27 22:41:32 +0000453 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
Steve French70ca7342005-09-22 16:32:06 -0700454
455 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000456 continue;
Steve French70ca7342005-09-22 16:32:06 -0700457 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Steve French467a8f82007-06-27 22:41:32 +0000458 cFYI(1, ("Good RFC 1002 session rsp"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700459 continue;
Steve French70ca7342005-09-22 16:32:06 -0700460 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000461 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700462 an error on SMB negprot response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000463 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
Steve French70ca7342005-09-22 16:32:06 -0700464 pdu_length));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000465 if (server->tcpStatus == CifsNew) {
466 /* if nack on negprot (rather than
Steve French46810cb2005-04-28 22:41:09 -0700467 ret of smb negprot error) reconnecting
468 not going to help, ret error to mount */
469 break;
470 } else {
471 /* give server a second to
472 clean up before reconnect attempt */
473 msleep(1000);
474 /* always try 445 first on reconnect
475 since we get NACK on some if we ever
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000476 connected to port 139 (the NACK is
Steve French46810cb2005-04-28 22:41:09 -0700477 since we do not begin with RFC1001
478 session initialize frame) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000479 server->addr.sockAddr.sin_port =
Steve French46810cb2005-04-28 22:41:09 -0700480 htons(CIFS_PORT);
481 cifs_reconnect(server);
482 csocket = server->ssocket;
483 wake_up(&server->response_q);
484 continue;
485 }
Steve French70ca7342005-09-22 16:32:06 -0700486 } else if (temp != (char) 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000487 cERROR(1, ("Unknown RFC 1002 frame"));
Steve French70ca7342005-09-22 16:32:06 -0700488 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
489 length);
Steve French46810cb2005-04-28 22:41:09 -0700490 cifs_reconnect(server);
491 csocket = server->ssocket;
492 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700493 }
494
495 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000496 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000497 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700498 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
Steve French46810cb2005-04-28 22:41:09 -0700499 length, pdu_length+4));
Steve Frenche4eb2952005-04-28 22:41:09 -0700500 cifs_reconnect(server);
501 csocket = server->ssocket;
502 wake_up(&server->response_q);
503 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000504 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700505
506 /* else length ok */
507 reconnect = 0;
508
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000509 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000510 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700511 memcpy(bigbuf, smallbuf, 4);
512 smb_buffer = bigbuf;
513 }
514 length = 0;
515 iov.iov_base = 4 + (char *)smb_buffer;
516 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000517 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700518 total_read += length) {
519 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
520 pdu_length - total_read, 0);
Jeff Layton469ee612008-10-16 18:46:39 +0000521 if ((server->tcpStatus == CifsExiting) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700522 (length == -EINTR)) {
523 /* then will exit */
524 reconnect = 2;
525 break;
526 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700527 cifs_reconnect(server);
528 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000529 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700530 /* Now we will reread sock */
531 reconnect = 1;
532 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000533 } else if ((length == -ERESTARTSYS) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700534 (length == -EAGAIN)) {
535 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000536 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700537 threads to set tcpStatus
538 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000539 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700540 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700541 } else if (length <= 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000542 cERROR(1, ("Received no data, expecting %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700543 pdu_length - total_read));
544 cifs_reconnect(server);
545 csocket = server->ssocket;
546 reconnect = 1;
547 break;
Steve French46810cb2005-04-28 22:41:09 -0700548 }
549 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000550 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700551 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000552 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700553 continue;
554
555 length += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000556
Steve Frenche4eb2952005-04-28 22:41:09 -0700557
558 dump_smb(smb_buffer, length);
Steve French184ed212006-02-24 06:15:11 +0000559 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
Steve Frenchb387eae2005-10-10 14:21:15 -0700560 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
Steve Frenche4eb2952005-04-28 22:41:09 -0700561 continue;
562 }
563
564
565 task_to_wake = NULL;
566 spin_lock(&GlobalMid_Lock);
567 list_for_each(tmp, &server->pending_mid_q) {
568 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
569
Steve French50c2f752007-07-13 00:33:32 +0000570 if ((mid_entry->mid == smb_buffer->Mid) &&
Steve Frenche4eb2952005-04-28 22:41:09 -0700571 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
572 (mid_entry->command == smb_buffer->Command)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000573 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700574 /* We have a multipart transact2 resp */
Steve French4b18f2a2008-04-29 00:06:05 +0000575 isMultiRsp = true;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000576 if (mid_entry->resp_buf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700577 /* merge response - fix up 1st*/
Steve French50c2f752007-07-13 00:33:32 +0000578 if (coalesce_t2(smb_buffer,
Steve Frenche4eb2952005-04-28 22:41:09 -0700579 mid_entry->resp_buf)) {
Steve French4b18f2a2008-04-29 00:06:05 +0000580 mid_entry->multiRsp =
581 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700582 break;
583 } else {
584 /* all parts received */
Steve French4b18f2a2008-04-29 00:06:05 +0000585 mid_entry->multiEnd =
586 true;
Steve French50c2f752007-07-13 00:33:32 +0000587 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700588 }
589 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000590 if (!isLargeBuf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700591 cERROR(1,("1st trans2 resp needs bigbuf"));
592 /* BB maybe we can fix this up, switch
Steve French50c2f752007-07-13 00:33:32 +0000593 to already allocated large buffer? */
Steve Frenche4eb2952005-04-28 22:41:09 -0700594 } else {
Steve Frenchcd634992005-04-28 22:41:10 -0700595 /* Have first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700596 mid_entry->resp_buf =
597 smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000598 mid_entry->largeBuf =
599 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700600 bigbuf = NULL;
601 }
602 }
603 break;
Steve French50c2f752007-07-13 00:33:32 +0000604 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700605 mid_entry->resp_buf = smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000606 mid_entry->largeBuf = isLargeBuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700607multi_t2_fnd:
608 task_to_wake = mid_entry->tsk;
609 mid_entry->midState = MID_RESPONSE_RECEIVED;
Steve French1047abc2005-10-11 19:58:06 -0700610#ifdef CONFIG_CIFS_STATS2
611 mid_entry->when_received = jiffies;
612#endif
Steve French3a5ff612006-07-14 22:37:11 +0000613 /* so we do not time out requests to server
614 which is still responding (since server could
615 be busy but not dead) */
616 server->lstrp = jiffies;
Steve Frenche4eb2952005-04-28 22:41:09 -0700617 break;
618 }
619 }
620 spin_unlock(&GlobalMid_Lock);
621 if (task_to_wake) {
Steve Frenchcd634992005-04-28 22:41:10 -0700622 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000623 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700624 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000625 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700626 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000627 else
Steve Frenchcd634992005-04-28 22:41:10 -0700628 smallbuf = NULL;
629 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700630 wake_up_process(task_to_wake);
Steve French4b18f2a2008-04-29 00:06:05 +0000631 } else if (!is_valid_oplock_break(smb_buffer, server) &&
632 !isMultiRsp) {
Steve French50c2f752007-07-13 00:33:32 +0000633 cERROR(1, ("No task to wake, unknown frame received! "
634 "NumMids %d", midCount.counter));
635 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700636 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000637#ifdef CONFIG_CIFS_DEBUG2
638 cifs_dump_detail(smb_buffer);
639 cifs_dump_mids(server);
640#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000641
Steve Frenche4eb2952005-04-28 22:41:09 -0700642 }
643 } /* end while !EXITING */
644
Jeff Laytone7ddee92008-11-14 13:44:38 -0500645 /* take it off the list, if it's not already */
646 write_lock(&cifs_tcp_ses_lock);
647 list_del_init(&server->tcp_ses_list);
648 write_unlock(&cifs_tcp_ses_lock);
649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 spin_lock(&GlobalMid_Lock);
651 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000652 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000653 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000654
Steve French31ca3bc2005-04-28 22:41:11 -0700655 /* check if we have blocked requests that need to free */
656 /* Note that cifs_max_pending is normally 50, but
657 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000658 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000659 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700660 atomic_set(&server->inFlight, cifs_max_pending - 1);
661 /* We do not want to set the max_pending too low or we
662 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000664 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700666 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 to the same server - they now will see the session is in exit state
668 and get out of SendReceive. */
669 wake_up_all(&server->request_q);
670 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700671 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000672
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000673 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 sock_release(csocket);
675 server->ssocket = NULL;
676 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700677 /* buffer usuallly freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000678 cifs_buf_release(bigbuf);
679 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700680 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Jeff Layton14fbf502008-11-14 13:53:46 -0500682 /*
683 * BB: we shouldn't have to do any of this. It shouldn't be
684 * possible to exit from the thread with active SMB sessions
685 */
686 read_lock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 if (list_empty(&server->pending_mid_q)) {
Steve French09d1db52005-04-28 22:41:08 -0700688 /* loop through server session structures attached to this and
689 mark them dead */
Jeff Layton14fbf502008-11-14 13:53:46 -0500690 list_for_each(tmp, &server->smb_ses_list) {
691 ses = list_entry(tmp, struct cifsSesInfo,
692 smb_ses_list);
693 ses->status = CifsExiting;
694 ses->server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500696 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 } else {
Steve French31ca3bc2005-04-28 22:41:11 -0700698 /* although we can not zero the server struct pointer yet,
699 since there are active requests which may depnd on them,
700 mark the corresponding SMB sessions as exiting too */
Jeff Layton14fbf502008-11-14 13:53:46 -0500701 list_for_each(tmp, &server->smb_ses_list) {
Steve French31ca3bc2005-04-28 22:41:11 -0700702 ses = list_entry(tmp, struct cifsSesInfo,
Jeff Layton14fbf502008-11-14 13:53:46 -0500703 smb_ses_list);
704 ses->status = CifsExiting;
Steve French31ca3bc2005-04-28 22:41:11 -0700705 }
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 spin_lock(&GlobalMid_Lock);
708 list_for_each(tmp, &server->pending_mid_q) {
709 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
710 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French50c2f752007-07-13 00:33:32 +0000711 cFYI(1, ("Clearing Mid 0x%x - waking up ",
712 mid_entry->mid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 task_to_wake = mid_entry->tsk;
Steve French26f57362007-08-30 22:09:15 +0000714 if (task_to_wake)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 wake_up_process(task_to_wake);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
717 }
718 spin_unlock(&GlobalMid_Lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500719 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700721 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 }
723
Steve Frenchf1914012005-08-18 09:37:34 -0700724 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000725 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700727 /* due to delays on oplock break requests, we need
728 to wait at least 45 seconds before giving up
729 on a request getting a response and going ahead
730 and killing cifsd */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 cFYI(1, ("Wait for exit from demultiplex thread"));
Steve French31ca3bc2005-04-28 22:41:11 -0700732 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 /* if threads still have not exited they are probably never
734 coming home not much else we can do but free the memory */
735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Steve French31ca3bc2005-04-28 22:41:11 -0700737 /* last chance to mark ses pointers invalid
738 if there are any pointing to this (e.g
Steve French50c2f752007-07-13 00:33:32 +0000739 if a crazy root user tried to kill cifsd
Steve French31ca3bc2005-04-28 22:41:11 -0700740 kernel thread explicitly this might happen) */
Jeff Layton14fbf502008-11-14 13:53:46 -0500741 /* BB: This shouldn't be necessary, see above */
742 read_lock(&cifs_tcp_ses_lock);
743 list_for_each(tmp, &server->smb_ses_list) {
744 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
745 ses->server = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700746 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500747 read_unlock(&cifs_tcp_ses_lock);
Steve French31ca3bc2005-04-28 22:41:11 -0700748
Jeff Laytonc359cf32007-11-16 22:22:06 +0000749 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400750 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700751 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400752
753 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000754 if (length > 0)
755 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
756 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000757
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400758 /* if server->tsk was NULL then wait for a signal before exiting */
759 if (!task_to_wake) {
760 set_current_state(TASK_INTERRUPTIBLE);
761 while (!signal_pending(current)) {
762 schedule();
763 set_current_state(TASK_INTERRUPTIBLE);
764 }
765 set_current_state(TASK_RUNNING);
766 }
767
Jeff Layton0468a2c2008-12-01 07:09:35 -0500768 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769}
770
Jeff Laytonc359cf32007-11-16 22:22:06 +0000771/* extract the host portion of the UNC string */
772static char *
773extract_hostname(const char *unc)
774{
775 const char *src;
776 char *dst, *delim;
777 unsigned int len;
778
779 /* skip double chars at beginning of string */
780 /* BB: check validity of these bytes? */
781 src = unc + 2;
782
783 /* delimiter between hostname and sharename is always '\\' now */
784 delim = strchr(src, '\\');
785 if (!delim)
786 return ERR_PTR(-EINVAL);
787
788 len = delim - src;
789 dst = kmalloc((len + 1), GFP_KERNEL);
790 if (dst == NULL)
791 return ERR_PTR(-ENOMEM);
792
793 memcpy(dst, src, len);
794 dst[len] = '\0';
795
796 return dst;
797}
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799static int
Steve French50c2f752007-07-13 00:33:32 +0000800cifs_parse_mount_options(char *options, const char *devname,
801 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
803 char *value;
804 char *data;
805 unsigned int temp_len, i, j;
806 char separator[2];
807
808 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000809 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Linus Torvalds12e36b22006-10-13 08:09:29 -0700811 if (Local_System_Name[0] != 0)
Steve French50c2f752007-07-13 00:33:32 +0000812 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
Steve French2cd646a2006-09-28 19:43:08 +0000813 else {
Linus Torvalds12e36b22006-10-13 08:09:29 -0700814 char *nodename = utsname()->nodename;
Steve French50c2f752007-07-13 00:33:32 +0000815 int n = strnlen(nodename, 15);
816 memset(vol->source_rfc1001_name, 0x20, 15);
817 for (i = 0; i < n; i++) {
Steve French2cd646a2006-09-28 19:43:08 +0000818 /* does not have to be perfect mapping since field is
819 informational, only used for servers that do not support
820 port 445 and it can be overridden at mount time */
Linus Torvalds12e36b22006-10-13 08:09:29 -0700821 vol->source_rfc1001_name[i] = toupper(nodename[i]);
Steve French2cd646a2006-09-28 19:43:08 +0000822 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
824 vol->source_rfc1001_name[15] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700825 /* null target name indicates to use *SMBSERVR default called name
826 if we end up sending RFC1001 session initialize */
827 vol->target_rfc1001_name[0] = 0;
David Howellsa001e5b2008-11-14 10:38:47 +1100828 vol->linux_uid = current_uid(); /* use current_euid() instead? */
829 vol->linux_gid = current_gid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 vol->dir_mode = S_IRWXUGO;
831 /* 2767 perms indicate mandatory locking support */
Steve French7505e052007-11-01 18:03:01 +0000832 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Steve French4b18f2a2008-04-29 00:06:05 +0000835 vol->rw = true;
Jeremy Allisonac670552005-06-22 17:26:35 -0700836 /* default is always to request posix paths. */
837 vol->posix_paths = 1;
838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 if (!options)
840 return 1;
841
Steve French50c2f752007-07-13 00:33:32 +0000842 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000843 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 separator[0] = options[4];
845 options += 5;
846 } else {
Steve French467a8f82007-06-27 22:41:32 +0000847 cFYI(1, ("Null separator not allowed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
849 }
Steve French50c2f752007-07-13 00:33:32 +0000850
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 while ((data = strsep(&options, separator)) != NULL) {
852 if (!*data)
853 continue;
854 if ((value = strchr(data, '=')) != NULL)
855 *value++ = '\0';
856
Steve French50c2f752007-07-13 00:33:32 +0000857 /* Have to parse this before we parse for "user" */
858 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000860 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 vol->no_xattr = 1;
862 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000863 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 printk(KERN_WARNING
865 "CIFS: invalid or missing username\n");
866 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000867 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000868 /* null user, ie anonymous, authentication */
869 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 }
871 if (strnlen(value, 200) < 200) {
872 vol->username = value;
873 } else {
874 printk(KERN_WARNING "CIFS: username too long\n");
875 return 1;
876 }
877 } else if (strnicmp(data, "pass", 4) == 0) {
878 if (!value) {
879 vol->password = NULL;
880 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000881 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 /* check if string begins with double comma
883 since that would mean the password really
884 does start with a comma, and would not
885 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000886 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 vol->password = NULL;
888 continue;
889 }
890 }
891 temp_len = strlen(value);
892 /* removed password length check, NTLM passwords
893 can be arbitrarily long */
894
Steve French50c2f752007-07-13 00:33:32 +0000895 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 prematurely null terminated. Commas in password are
897 specified across the cifs mount interface by a double
898 comma ie ,, and a comma used as in other cases ie ','
899 as a parameter delimiter/separator is single and due
900 to the strsep above is temporarily zeroed. */
901
902 /* NB: password legally can have multiple commas and
903 the only illegal character in a password is null */
904
Steve French50c2f752007-07-13 00:33:32 +0000905 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700906 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 /* reinsert comma */
908 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000909 temp_len += 2; /* move after second comma */
910 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000912 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700913 separator[0]) {
914 /* skip second comma */
915 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000916 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 /* single comma indicating start
918 of next parm */
919 break;
920 }
921 }
922 temp_len++;
923 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000924 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 options = NULL;
926 } else {
927 value[temp_len] = 0;
928 /* point option to start of next parm */
929 options = value + temp_len + 1;
930 }
Steve French50c2f752007-07-13 00:33:32 +0000931 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 double commas to singles. Note that this ends up
933 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700934 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000935 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000936 printk(KERN_WARNING "CIFS: no memory "
937 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700938 return 1;
939 }
Steve French50c2f752007-07-13 00:33:32 +0000940 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000942 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700943 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 /* skip second comma */
945 i++;
946 }
947 }
948 vol->password[j] = 0;
949 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700950 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000951 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000952 printk(KERN_WARNING "CIFS: no memory "
953 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700954 return 1;
955 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 strcpy(vol->password, value);
957 }
958 } else if (strnicmp(data, "ip", 2) == 0) {
959 if (!value || !*value) {
960 vol->UNCip = NULL;
961 } else if (strnlen(value, 35) < 35) {
962 vol->UNCip = value;
963 } else {
Steve French50c2f752007-07-13 00:33:32 +0000964 printk(KERN_WARNING "CIFS: ip address "
965 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 return 1;
967 }
Steve French50c2f752007-07-13 00:33:32 +0000968 } else if (strnicmp(data, "sec", 3) == 0) {
969 if (!value || !*value) {
970 cERROR(1, ("no security value specified"));
971 continue;
972 } else if (strnicmp(value, "krb5i", 5) == 0) {
973 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000974 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800975 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000976 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
977 CIFSSEC_MAY_KRB5; */
978 cERROR(1, ("Krb5 cifs privacy not supported"));
Steve Frenchbf820672005-12-01 22:32:42 -0800979 return 1;
980 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000981 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchbf820672005-12-01 22:32:42 -0800982 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000983 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000984 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800985 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000986 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -0800987 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000988 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +0000989 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800990 } else if (strnicmp(value, "ntlm", 4) == 0) {
991 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +0000992 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -0800993 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +0000994 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +0000995 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +0000996#ifdef CONFIG_CIFS_WEAK_PW_HASH
997 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000998 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +0000999#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001000 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001001 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001002 } else {
1003 cERROR(1, ("bad security option: %s", value));
1004 return 1;
1005 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 } else if ((strnicmp(data, "unc", 3) == 0)
1007 || (strnicmp(data, "target", 6) == 0)
1008 || (strnicmp(data, "path", 4) == 0)) {
1009 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001010 printk(KERN_WARNING "CIFS: invalid path to "
1011 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 return 1; /* needs_arg; */
1013 }
1014 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001015 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001016 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001018 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 if (strncmp(vol->UNC, "//", 2) == 0) {
1020 vol->UNC[0] = '\\';
1021 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001022 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001024 "CIFS: UNC Path does not begin "
1025 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 return 1;
1027 }
1028 } else {
1029 printk(KERN_WARNING "CIFS: UNC name too long\n");
1030 return 1;
1031 }
1032 } else if ((strnicmp(data, "domain", 3) == 0)
1033 || (strnicmp(data, "workgroup", 5) == 0)) {
1034 if (!value || !*value) {
1035 printk(KERN_WARNING "CIFS: invalid domain name\n");
1036 return 1; /* needs_arg; */
1037 }
1038 /* BB are there cases in which a comma can be valid in
1039 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001040 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 vol->domainname = value;
1042 cFYI(1, ("Domain name set"));
1043 } else {
Steve French50c2f752007-07-13 00:33:32 +00001044 printk(KERN_WARNING "CIFS: domain name too "
1045 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 return 1;
1047 }
Steve French50c2f752007-07-13 00:33:32 +00001048 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1049 if (!value || !*value) {
1050 printk(KERN_WARNING
1051 "CIFS: invalid path prefix\n");
1052 return 1; /* needs_argument */
1053 }
1054 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001055 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001056 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001057 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1058 if (vol->prepath == NULL)
1059 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001060 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001061 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001062 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001063 } else
Steve French50c2f752007-07-13 00:33:32 +00001064 strcpy(vol->prepath, value);
1065 cFYI(1, ("prefix path %s", vol->prepath));
1066 } else {
1067 printk(KERN_WARNING "CIFS: prefix too long\n");
1068 return 1;
1069 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 } else if (strnicmp(data, "iocharset", 9) == 0) {
1071 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001072 printk(KERN_WARNING "CIFS: invalid iocharset "
1073 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 return 1; /* needs_arg; */
1075 }
1076 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001077 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001079 /* if iocharset not set then load_nls_default
1080 is used by caller */
1081 cFYI(1, ("iocharset set to %s", value));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 } else {
Steve French63135e02007-07-17 17:34:02 +00001083 printk(KERN_WARNING "CIFS: iocharset name "
1084 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 return 1;
1086 }
1087 } else if (strnicmp(data, "uid", 3) == 0) {
1088 if (value && *value) {
1089 vol->linux_uid =
1090 simple_strtoul(value, &value, 0);
Steve French4523cc32007-04-30 20:13:06 +00001091 vol->override_uid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 }
1093 } else if (strnicmp(data, "gid", 3) == 0) {
1094 if (value && *value) {
1095 vol->linux_gid =
1096 simple_strtoul(value, &value, 0);
Steve French4523cc32007-04-30 20:13:06 +00001097 vol->override_gid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 }
1099 } else if (strnicmp(data, "file_mode", 4) == 0) {
1100 if (value && *value) {
1101 vol->file_mode =
1102 simple_strtoul(value, &value, 0);
1103 }
1104 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1105 if (value && *value) {
1106 vol->dir_mode =
1107 simple_strtoul(value, &value, 0);
1108 }
1109 } else if (strnicmp(data, "dirmode", 4) == 0) {
1110 if (value && *value) {
1111 vol->dir_mode =
1112 simple_strtoul(value, &value, 0);
1113 }
1114 } else if (strnicmp(data, "port", 4) == 0) {
1115 if (value && *value) {
1116 vol->port =
1117 simple_strtoul(value, &value, 0);
1118 }
1119 } else if (strnicmp(data, "rsize", 5) == 0) {
1120 if (value && *value) {
1121 vol->rsize =
1122 simple_strtoul(value, &value, 0);
1123 }
1124 } else if (strnicmp(data, "wsize", 5) == 0) {
1125 if (value && *value) {
1126 vol->wsize =
1127 simple_strtoul(value, &value, 0);
1128 }
1129 } else if (strnicmp(data, "sockopt", 5) == 0) {
1130 if (value && *value) {
1131 vol->sockopt =
1132 simple_strtoul(value, &value, 0);
1133 }
1134 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1135 if (!value || !*value || (*value == ' ')) {
Steve French63135e02007-07-17 17:34:02 +00001136 cFYI(1, ("invalid (empty) netbiosname"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 } else {
Steve French50c2f752007-07-13 00:33:32 +00001138 memset(vol->source_rfc1001_name, 0x20, 15);
1139 for (i = 0; i < 15; i++) {
1140 /* BB are there cases in which a comma can be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 valid in this workstation netbios name (and need
1142 special handling)? */
1143
1144 /* We do not uppercase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001145 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 break;
Steve French50c2f752007-07-13 00:33:32 +00001147 else
1148 vol->source_rfc1001_name[i] =
1149 value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 }
1151 /* The string has 16th byte zero still from
1152 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001153 if ((i == 15) && (value[i] != 0))
1154 printk(KERN_WARNING "CIFS: netbiosname"
1155 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001156 }
1157 } else if (strnicmp(data, "servern", 7) == 0) {
1158 /* servernetbiosname specified override *SMBSERVER */
1159 if (!value || !*value || (*value == ' ')) {
Steve French467a8f82007-06-27 22:41:32 +00001160 cFYI(1, ("empty server netbiosname specified"));
Steve Frencha10faeb22005-08-22 21:38:31 -07001161 } else {
1162 /* last byte, type, is 0x20 for servr type */
Steve French50c2f752007-07-13 00:33:32 +00001163 memset(vol->target_rfc1001_name, 0x20, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001164
Steve French50c2f752007-07-13 00:33:32 +00001165 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001166 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001167 valid in this workstation netbios name
1168 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001169
Steve French50c2f752007-07-13 00:33:32 +00001170 /* user or mount helper must uppercase
1171 the netbiosname */
1172 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001173 break;
1174 else
Steve French50c2f752007-07-13 00:33:32 +00001175 vol->target_rfc1001_name[i] =
1176 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001177 }
1178 /* The string has 16th byte zero still from
1179 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001180 if ((i == 15) && (value[i] != 0))
1181 printk(KERN_WARNING "CIFS: server net"
1182 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
1184 } else if (strnicmp(data, "credentials", 4) == 0) {
1185 /* ignore */
1186 } else if (strnicmp(data, "version", 3) == 0) {
1187 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001188 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 /* ignore */
1190 } else if (strnicmp(data, "rw", 2) == 0) {
Steve French4b18f2a2008-04-29 00:06:05 +00001191 vol->rw = true;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001192 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1193 vol->noblocksnd = 1;
1194 } else if (strnicmp(data, "noautotune", 10) == 0) {
1195 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 } else if ((strnicmp(data, "suid", 4) == 0) ||
1197 (strnicmp(data, "nosuid", 6) == 0) ||
1198 (strnicmp(data, "exec", 4) == 0) ||
1199 (strnicmp(data, "noexec", 6) == 0) ||
1200 (strnicmp(data, "nodev", 5) == 0) ||
1201 (strnicmp(data, "noauto", 6) == 0) ||
1202 (strnicmp(data, "dev", 3) == 0)) {
1203 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001204 uses these opts to set flags, and the flags are read
1205 by the kernel vfs layer before we get here (ie
1206 before read super) so there is no point trying to
1207 parse these options again and set anything and it
1208 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 continue;
1210 } else if (strnicmp(data, "ro", 2) == 0) {
Steve French4b18f2a2008-04-29 00:06:05 +00001211 vol->rw = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 } else if (strnicmp(data, "hard", 4) == 0) {
1213 vol->retry = 1;
1214 } else if (strnicmp(data, "soft", 4) == 0) {
1215 vol->retry = 0;
1216 } else if (strnicmp(data, "perm", 4) == 0) {
1217 vol->noperm = 0;
1218 } else if (strnicmp(data, "noperm", 6) == 0) {
1219 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001220 } else if (strnicmp(data, "mapchars", 8) == 0) {
1221 vol->remap = 1;
1222 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1223 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001224 } else if (strnicmp(data, "sfu", 3) == 0) {
1225 vol->sfu_emul = 1;
1226 } else if (strnicmp(data, "nosfu", 5) == 0) {
1227 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001228 } else if (strnicmp(data, "nodfs", 5) == 0) {
1229 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001230 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1231 vol->posix_paths = 1;
1232 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1233 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001234 } else if (strnicmp(data, "nounix", 6) == 0) {
1235 vol->no_linux_ext = 1;
1236 } else if (strnicmp(data, "nolinux", 7) == 0) {
1237 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001238 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001239 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001240 vol->nocase = 1;
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001241 } else if (strnicmp(data, "brl", 3) == 0) {
1242 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001243 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001244 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001245 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001246 /* turn off mandatory locking in mode
1247 if remote locking is turned off since the
1248 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001249 if (vol->file_mode ==
1250 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001251 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001252 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1253 /* will take the shorter form "forcemand" as well */
1254 /* This mount option will force use of mandatory
1255 (DOS/Windows style) byte range locks, instead of
1256 using posix advisory byte range locks, even if the
1257 Unix extensions are available and posix locks would
1258 be supported otherwise. If Unix extensions are not
1259 negotiated this has no effect since mandatory locks
1260 would be used (mandatory locks is all that those
1261 those servers support) */
1262 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 } else if (strnicmp(data, "setuids", 7) == 0) {
1264 vol->setuids = 1;
1265 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1266 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001267 } else if (strnicmp(data, "dynperm", 7) == 0) {
1268 vol->dynperm = true;
1269 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1270 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 } else if (strnicmp(data, "nohard", 6) == 0) {
1272 vol->retry = 0;
1273 } else if (strnicmp(data, "nosoft", 6) == 0) {
1274 vol->retry = 1;
1275 } else if (strnicmp(data, "nointr", 6) == 0) {
1276 vol->intr = 0;
1277 } else if (strnicmp(data, "intr", 4) == 0) {
1278 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001279 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1280 vol->nostrictsync = 1;
1281 } else if (strnicmp(data, "strictsync", 10) == 0) {
1282 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001283 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001285 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001287 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001288 vol->cifs_acl = 1;
1289 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1290 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001291 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001293 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001295#ifdef CONFIG_CIFS_EXPERIMENTAL
1296 } else if (strnicmp(data, "locallease", 6) == 0) {
1297 vol->local_lease = 1;
1298#endif
Steve French50c2f752007-07-13 00:33:32 +00001299 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001300 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001301 } else if (strnicmp(data, "seal", 4) == 0) {
1302 /* we do not do the following in secFlags because seal
1303 is a per tree connection (mount) not a per socket
1304 or per-smb connection option in the protocol */
1305 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1306 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001307 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001309 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001311 } else if (strnicmp(data, "in6_addr", 8) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 if (!value || !*value) {
1313 vol->in6_addr = NULL;
1314 } else if (strnlen(value, 49) == 48) {
1315 vol->in6_addr = value;
1316 } else {
Steve French50c2f752007-07-13 00:33:32 +00001317 printk(KERN_WARNING "CIFS: ip v6 address not "
1318 "48 characters long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 return 1;
1320 }
1321 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001322 printk(KERN_WARNING "CIFS: Mount option noac not "
1323 "supported. Instead set "
1324 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 } else
Steve French50c2f752007-07-13 00:33:32 +00001326 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1327 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001330 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001331 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1332 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 return 1;
1334 }
1335 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001336 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001337 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001339 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 if (strncmp(vol->UNC, "//", 2) == 0) {
1341 vol->UNC[0] = '\\';
1342 vol->UNC[1] = '\\';
1343 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001344 printk(KERN_WARNING "CIFS: UNC Path does not "
1345 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 return 1;
1347 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001348 value = strpbrk(vol->UNC+2, "/\\");
1349 if (value)
1350 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 } else {
1352 printk(KERN_WARNING "CIFS: UNC name too long\n");
1353 return 1;
1354 }
1355 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001356 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 vol->UNCip = &vol->UNC[2];
1358
1359 return 0;
1360}
1361
Jeff Laytone7ddee92008-11-14 13:44:38 -05001362static struct TCP_Server_Info *
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001363cifs_find_tcp_session(struct sockaddr_storage *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364{
1365 struct list_head *tmp;
Jeff Laytone7ddee92008-11-14 13:44:38 -05001366 struct TCP_Server_Info *server;
1367 struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1368 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
Jeff Laytone7ddee92008-11-14 13:44:38 -05001370 write_lock(&cifs_tcp_ses_lock);
1371 list_for_each(tmp, &cifs_tcp_ses_list) {
1372 server = list_entry(tmp, struct TCP_Server_Info,
1373 tcp_ses_list);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001374 /*
1375 * the demux thread can exit on its own while still in CifsNew
1376 * so don't accept any sockets in that state. Since the
1377 * tcpStatus never changes back to CifsNew it's safe to check
1378 * for this without a lock.
1379 */
1380 if (server->tcpStatus == CifsNew)
Cyrill Gorcunov1b20d672008-05-09 18:17:21 +00001381 continue;
Steve French50c2f752007-07-13 00:33:32 +00001382
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001383 if (addr->ss_family == AF_INET &&
Jeff Laytone7ddee92008-11-14 13:44:38 -05001384 (addr4->sin_addr.s_addr !=
1385 server->addr.sockAddr.sin_addr.s_addr))
1386 continue;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001387 else if (addr->ss_family == AF_INET6 &&
Steve French0e2beda2009-01-30 21:24:41 +00001388 !ipv6_addr_equal(&server->addr.sockAddr6.sin6_addr,
1389 &addr6->sin6_addr))
Jeff Laytone7ddee92008-11-14 13:44:38 -05001390 continue;
Steve French50c2f752007-07-13 00:33:32 +00001391
Jeff Laytone7ddee92008-11-14 13:44:38 -05001392 ++server->srv_count;
1393 write_unlock(&cifs_tcp_ses_lock);
Steve Frenchd82c2df2008-11-15 00:07:26 +00001394 cFYI(1, ("Existing tcp session with server found"));
Jeff Laytone7ddee92008-11-14 13:44:38 -05001395 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 }
Jeff Laytone7ddee92008-11-14 13:44:38 -05001397 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 return NULL;
1399}
1400
Jeff Layton14fbf502008-11-14 13:53:46 -05001401static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001402cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001404 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405
Jeff Laytone7ddee92008-11-14 13:44:38 -05001406 write_lock(&cifs_tcp_ses_lock);
1407 if (--server->srv_count > 0) {
1408 write_unlock(&cifs_tcp_ses_lock);
1409 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001411
Jeff Laytone7ddee92008-11-14 13:44:38 -05001412 list_del_init(&server->tcp_ses_list);
1413 write_unlock(&cifs_tcp_ses_lock);
1414
1415 spin_lock(&GlobalMid_Lock);
1416 server->tcpStatus = CifsExiting;
1417 spin_unlock(&GlobalMid_Lock);
1418
1419 task = xchg(&server->tsk, NULL);
1420 if (task)
1421 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422}
1423
Jeff Layton63c038c2008-12-01 18:41:46 -05001424static struct TCP_Server_Info *
1425cifs_get_tcp_session(struct smb_vol *volume_info)
1426{
1427 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001428 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001429 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1430 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1431 int rc;
1432
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001433 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001434
1435 if (volume_info->UNCip && volume_info->UNC) {
1436 rc = cifs_inet_pton(AF_INET, volume_info->UNCip,
1437 &sin_server->sin_addr.s_addr);
1438
1439 if (rc <= 0) {
1440 /* not ipv4 address, try ipv6 */
1441 rc = cifs_inet_pton(AF_INET6, volume_info->UNCip,
1442 &sin_server6->sin6_addr.in6_u);
1443 if (rc > 0)
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001444 addr.ss_family = AF_INET6;
Jeff Layton63c038c2008-12-01 18:41:46 -05001445 } else {
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001446 addr.ss_family = AF_INET;
Jeff Layton63c038c2008-12-01 18:41:46 -05001447 }
1448
1449 if (rc <= 0) {
1450 /* we failed translating address */
1451 rc = -EINVAL;
1452 goto out_err;
1453 }
1454
1455 cFYI(1, ("UNC: %s ip: %s", volume_info->UNC,
1456 volume_info->UNCip));
1457 } else if (volume_info->UNCip) {
1458 /* BB using ip addr as tcp_ses name to connect to the
1459 DFS root below */
1460 cERROR(1, ("Connecting to DFS root not implemented yet"));
1461 rc = -EINVAL;
1462 goto out_err;
1463 } else /* which tcp_sess DFS root would we conect to */ {
1464 cERROR(1,
1465 ("CIFS mount error: No UNC path (e.g. -o "
1466 "unc=//192.168.1.100/public) specified"));
1467 rc = -EINVAL;
1468 goto out_err;
1469 }
1470
1471 /* see if we already have a matching tcp_ses */
1472 tcp_ses = cifs_find_tcp_session(&addr);
1473 if (tcp_ses)
1474 return tcp_ses;
1475
1476 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1477 if (!tcp_ses) {
1478 rc = -ENOMEM;
1479 goto out_err;
1480 }
1481
1482 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1483 if (IS_ERR(tcp_ses->hostname)) {
1484 rc = PTR_ERR(tcp_ses->hostname);
1485 goto out_err;
1486 }
1487
1488 tcp_ses->noblocksnd = volume_info->noblocksnd;
1489 tcp_ses->noautotune = volume_info->noautotune;
1490 atomic_set(&tcp_ses->inFlight, 0);
1491 init_waitqueue_head(&tcp_ses->response_q);
1492 init_waitqueue_head(&tcp_ses->request_q);
1493 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1494 mutex_init(&tcp_ses->srv_mutex);
1495 memcpy(tcp_ses->workstation_RFC1001_name,
1496 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1497 memcpy(tcp_ses->server_RFC1001_name,
1498 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1499 tcp_ses->sequence_number = 0;
1500 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1501 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1502
1503 /*
1504 * at this point we are the only ones with the pointer
1505 * to the struct since the kernel thread not created yet
1506 * no need to spinlock this init of tcpStatus or srv_count
1507 */
1508 tcp_ses->tcpStatus = CifsNew;
1509 ++tcp_ses->srv_count;
1510
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001511 if (addr.ss_family == AF_INET6) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001512 cFYI(1, ("attempting ipv6 connect"));
1513 /* BB should we allow ipv6 on port 139? */
1514 /* other OS never observed in Wild doing 139 with v6 */
1515 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1516 sizeof(struct sockaddr_in6));
1517 sin_server6->sin6_port = htons(volume_info->port);
Jeff Laytond5c56052008-12-01 18:42:33 -05001518 rc = ipv6_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001519 } else {
1520 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1521 sizeof(struct sockaddr_in));
1522 sin_server->sin_port = htons(volume_info->port);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001523 rc = ipv4_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001524 }
1525 if (rc < 0) {
1526 cERROR(1, ("Error connecting to socket. Aborting operation"));
1527 goto out_err;
1528 }
1529
1530 /*
1531 * since we're in a cifs function already, we know that
1532 * this will succeed. No need for try_module_get().
1533 */
1534 __module_get(THIS_MODULE);
1535 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1536 tcp_ses, "cifsd");
1537 if (IS_ERR(tcp_ses->tsk)) {
1538 rc = PTR_ERR(tcp_ses->tsk);
1539 cERROR(1, ("error %d create cifsd thread", rc));
1540 module_put(THIS_MODULE);
1541 goto out_err;
1542 }
1543
1544 /* thread spawned, put it on the list */
1545 write_lock(&cifs_tcp_ses_lock);
1546 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1547 write_unlock(&cifs_tcp_ses_lock);
1548
1549 return tcp_ses;
1550
1551out_err:
1552 if (tcp_ses) {
1553 kfree(tcp_ses->hostname);
1554 if (tcp_ses->ssocket)
1555 sock_release(tcp_ses->ssocket);
1556 kfree(tcp_ses);
1557 }
1558 return ERR_PTR(rc);
1559}
1560
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561static struct cifsSesInfo *
Jeff Layton14fbf502008-11-14 13:53:46 -05001562cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563{
1564 struct list_head *tmp;
1565 struct cifsSesInfo *ses;
1566
Jeff Layton14fbf502008-11-14 13:53:46 -05001567 write_lock(&cifs_tcp_ses_lock);
1568 list_for_each(tmp, &server->smb_ses_list) {
1569 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1570 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 continue;
1572
Jeff Layton14fbf502008-11-14 13:53:46 -05001573 ++ses->ses_count;
1574 write_unlock(&cifs_tcp_ses_lock);
1575 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001577 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 return NULL;
1579}
1580
Jeff Layton14fbf502008-11-14 13:53:46 -05001581static void
1582cifs_put_smb_ses(struct cifsSesInfo *ses)
1583{
1584 int xid;
1585 struct TCP_Server_Info *server = ses->server;
1586
1587 write_lock(&cifs_tcp_ses_lock);
1588 if (--ses->ses_count > 0) {
1589 write_unlock(&cifs_tcp_ses_lock);
1590 return;
1591 }
1592
1593 list_del_init(&ses->smb_ses_list);
1594 write_unlock(&cifs_tcp_ses_lock);
1595
1596 if (ses->status == CifsGood) {
1597 xid = GetXid();
1598 CIFSSMBLogoff(xid, ses);
1599 _FreeXid(xid);
1600 }
1601 sesInfoFree(ses);
1602 cifs_put_tcp_session(server);
1603}
1604
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05001606cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607{
1608 struct list_head *tmp;
1609 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
Jeff Laytonf1987b42008-11-15 11:12:47 -05001611 write_lock(&cifs_tcp_ses_lock);
1612 list_for_each(tmp, &ses->tcon_list) {
1613 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1614 if (tcon->tidStatus == CifsExiting)
1615 continue;
1616 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 continue;
1618
Jeff Laytonf1987b42008-11-15 11:12:47 -05001619 ++tcon->tc_count;
1620 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 return tcon;
1622 }
Jeff Laytonf1987b42008-11-15 11:12:47 -05001623 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 return NULL;
1625}
1626
Jeff Laytonf1987b42008-11-15 11:12:47 -05001627static void
1628cifs_put_tcon(struct cifsTconInfo *tcon)
1629{
1630 int xid;
1631 struct cifsSesInfo *ses = tcon->ses;
1632
1633 write_lock(&cifs_tcp_ses_lock);
1634 if (--tcon->tc_count > 0) {
1635 write_unlock(&cifs_tcp_ses_lock);
1636 return;
1637 }
1638
1639 list_del_init(&tcon->tcon_list);
1640 write_unlock(&cifs_tcp_ses_lock);
1641
1642 xid = GetXid();
1643 CIFSSMBTDis(xid, tcon);
1644 _FreeXid(xid);
1645
1646 DeleteTconOplockQEntries(tcon);
1647 tconInfoFree(tcon);
1648 cifs_put_smb_ses(ses);
1649}
1650
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651int
Steve French50c2f752007-07-13 00:33:32 +00001652get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1653 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00001654 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655{
1656 char *temp_unc;
1657 int rc = 0;
1658
1659 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00001660 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
1662 if (pSesInfo->ipc_tid == 0) {
1663 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00001664 strnlen(pSesInfo->serverName,
1665 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 + 1 + 4 /* slash IPC$ */ + 2,
1667 GFP_KERNEL);
1668 if (temp_unc == NULL)
1669 return -ENOMEM;
1670 temp_unc[0] = '\\';
1671 temp_unc[1] = '\\';
1672 strcpy(temp_unc + 2, pSesInfo->serverName);
1673 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1674 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1675 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00001676 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 kfree(temp_unc);
1678 }
1679 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00001680 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07001681 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00001682 /* BB map targetUNCs to dfs_info3 structures, here or
1683 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
1685 return rc;
1686}
1687
Jeff Layton09e50d52008-07-23 10:11:19 -04001688#ifdef CONFIG_DEBUG_LOCK_ALLOC
1689static struct lock_class_key cifs_key[2];
1690static struct lock_class_key cifs_slock_key[2];
1691
1692static inline void
1693cifs_reclassify_socket4(struct socket *sock)
1694{
1695 struct sock *sk = sock->sk;
1696 BUG_ON(sock_owned_by_user(sk));
1697 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1698 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1699}
1700
1701static inline void
1702cifs_reclassify_socket6(struct socket *sock)
1703{
1704 struct sock *sk = sock->sk;
1705 BUG_ON(sock_owned_by_user(sk));
1706 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1707 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1708}
1709#else
1710static inline void
1711cifs_reclassify_socket4(struct socket *sock)
1712{
1713}
1714
1715static inline void
1716cifs_reclassify_socket6(struct socket *sock)
1717{
1718}
1719#endif
1720
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00001722static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723{
Steve French50c2f752007-07-13 00:33:32 +00001724 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Steve French50c2f752007-07-13 00:33:32 +00001726 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 /* mask a nibble at a time and encode */
1728 target[j] = 'A' + (0x0F & (source[i] >> 4));
1729 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00001730 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 }
1732
1733}
1734
1735
1736static int
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001737ipv4_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738{
1739 int rc = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001740 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 __be16 orig_port = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001742 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001744 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001745 rc = sock_create_kern(PF_INET, SOCK_STREAM,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001746 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001748 cERROR(1, ("Error %d creating socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001751
1752 /* BB other socket options to set KEEPALIVE, NODELAY? */
1753 cFYI(1, ("Socket created"));
1754 server->ssocket = socket;
1755 socket->sk->sk_allocation = GFP_NOFS;
1756 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
1758
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001759 /* user overrode default port */
1760 if (server->addr.sockAddr.sin_port) {
1761 rc = socket->ops->connect(socket, (struct sockaddr *)
1762 &server->addr.sockAddr,
1763 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001765 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001766 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001768 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001769 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 later if fall back ports fail this time */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001771 orig_port = server->addr.sockAddr.sin_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
1773 /* do not retry on the same port we just failed on */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001774 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
1775 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
1776 rc = socket->ops->connect(socket,
1777 (struct sockaddr *)
1778 &server->addr.sockAddr,
1779 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001781 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 }
1783 }
1784 if (!connected) {
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001785 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
1786 rc = socket->ops->connect(socket, (struct sockaddr *)
1787 &server->addr.sockAddr,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001788 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00001789 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001790 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
1792
1793 /* give up here - unless we want to retry on different
1794 protocol families some day */
1795 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001796 if (orig_port)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001797 server->addr.sockAddr.sin_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001798 cFYI(1, ("Error %d connecting to server via ipv4", rc));
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001799 sock_release(socket);
1800 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 return rc;
1802 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001803
1804
1805 /*
1806 * Eventually check for other socket options to change from
1807 * the default. sock_setsockopt not used because it expects
1808 * user space buffer
1809 */
1810 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001811 socket->sk->sk_sndtimeo = 5 * HZ;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001812
Steve Frenchb387eae2005-10-10 14:21:15 -07001813 /* make the bufsizes depend on wsize/rsize and max requests */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001814 if (server->noautotune) {
1815 if (socket->sk->sk_sndbuf < (200 * 1024))
1816 socket->sk->sk_sndbuf = 200 * 1024;
1817 if (socket->sk->sk_rcvbuf < (140 * 1024))
1818 socket->sk->sk_rcvbuf = 140 * 1024;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001819 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001821 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1822 socket->sk->sk_sndbuf,
1823 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo));
1824
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 /* send RFC1001 sessinit */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001826 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00001828 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00001830 struct rfc1002_session_packet *ses_init_buf;
1831 struct smb_hdr *smb_buf;
1832 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1833 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001834 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 ses_init_buf->trailer.session_req.called_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001836 if (server->server_RFC1001_name &&
1837 server->server_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001838 rfc1002mangle(ses_init_buf->trailer.
1839 session_req.called_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001840 server->server_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001841 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001842 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001843 rfc1002mangle(ses_init_buf->trailer.
1844 session_req.called_name,
1845 DEFAULT_CIFS_CALLED_NAME,
1846 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001847
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 ses_init_buf->trailer.session_req.calling_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001849
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 /* calling name ends in null (byte 16) from old smb
1851 convention. */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001852 if (server->workstation_RFC1001_name &&
1853 server->workstation_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001854 rfc1002mangle(ses_init_buf->trailer.
1855 session_req.calling_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001856 server->workstation_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001857 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001858 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001859 rfc1002mangle(ses_init_buf->trailer.
1860 session_req.calling_name,
1861 "LINUX_CIFS_CLNT",
1862 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 ses_init_buf->trailer.session_req.scope1 = 0;
1865 ses_init_buf->trailer.session_req.scope2 = 0;
1866 smb_buf = (struct smb_hdr *)ses_init_buf;
1867 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1868 smb_buf->smb_buf_length = 0x81000044;
Jeff Layton0496e022008-12-30 12:39:16 -05001869 rc = smb_send(server, smb_buf, 0x44);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00001871 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00001872 requires very short break before negprot
1873 presumably because not expecting negprot
1874 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00001875 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00001876 complicating the code and causes no
1877 significant slowing down on mount
1878 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 }
Steve French50c2f752007-07-13 00:33:32 +00001880 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00001882
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 }
Steve French50c2f752007-07-13 00:33:32 +00001884
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 return rc;
1886}
1887
1888static int
Jeff Laytond5c56052008-12-01 18:42:33 -05001889ipv6_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890{
1891 int rc = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001892 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 __be16 orig_port = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001894 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Jeff Laytond5c56052008-12-01 18:42:33 -05001896 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001897 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
Jeff Laytond5c56052008-12-01 18:42:33 -05001898 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001900 cERROR(1, ("Error %d creating ipv6 socket", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001901 socket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 }
Jeff Laytond5c56052008-12-01 18:42:33 -05001904
1905 /* BB other socket options to set KEEPALIVE, NODELAY? */
1906 cFYI(1, ("ipv6 Socket created"));
1907 server->ssocket = socket;
1908 socket->sk->sk_allocation = GFP_NOFS;
1909 cifs_reclassify_socket6(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 }
1911
Jeff Laytond5c56052008-12-01 18:42:33 -05001912 /* user overrode default port */
1913 if (server->addr.sockAddr6.sin6_port) {
1914 rc = socket->ops->connect(socket,
1915 (struct sockaddr *) &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001916 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001918 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001919 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001921 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001922 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 later if fall back ports fail this time */
1924
Jeff Laytond5c56052008-12-01 18:42:33 -05001925 orig_port = server->addr.sockAddr6.sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 /* do not retry on the same port we just failed on */
Jeff Laytond5c56052008-12-01 18:42:33 -05001927 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
1928 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
1929 rc = socket->ops->connect(socket, (struct sockaddr *)
1930 &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001931 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001933 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 }
1935 }
1936 if (!connected) {
Jeff Laytond5c56052008-12-01 18:42:33 -05001937 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
1938 rc = socket->ops->connect(socket, (struct sockaddr *)
1939 &server->addr.sockAddr6,
1940 sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00001941 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001942 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 }
1944
1945 /* give up here - unless we want to retry on different
1946 protocol families some day */
1947 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001948 if (orig_port)
Jeff Laytond5c56052008-12-01 18:42:33 -05001949 server->addr.sockAddr6.sin6_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001950 cFYI(1, ("Error %d connecting to server via ipv6", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001951 sock_release(socket);
1952 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 return rc;
1954 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00001955
Jeff Laytond5c56052008-12-01 18:42:33 -05001956 /*
1957 * Eventually check for other socket options to change from
1958 * the default. sock_setsockopt not used because it expects
1959 * user space buffer
1960 */
1961 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001962 socket->sk->sk_sndtimeo = 5 * HZ;
Jeff Laytond5c56052008-12-01 18:42:33 -05001963 server->ssocket = socket;
Steve French50c2f752007-07-13 00:33:32 +00001964
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 return rc;
1966}
1967
Steve French50c2f752007-07-13 00:33:32 +00001968void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1969 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00001970{
1971 /* if we are reconnecting then should we check to see if
1972 * any requested capabilities changed locally e.g. via
1973 * remount but we can not do much about it here
1974 * if they have (even if we could detect it by the following)
1975 * Perhaps we could add a backpointer to array of sb from tcon
1976 * or if we change to make all sb to same share the same
1977 * sb as NFS - then we only have one backpointer to sb.
1978 * What if we wanted to mount the server share twice once with
1979 * and once without posixacls or posix paths? */
1980 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001981
Steve Frenchc18c8422007-07-18 23:21:09 +00001982 if (vol_info && vol_info->no_linux_ext) {
1983 tcon->fsUnixInfo.Capability = 0;
1984 tcon->unix_ext = 0; /* Unix Extensions disabled */
1985 cFYI(1, ("Linux protocol extensions disabled"));
1986 return;
1987 } else if (vol_info)
1988 tcon->unix_ext = 1; /* Unix Extensions supported */
1989
1990 if (tcon->unix_ext == 0) {
1991 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1992 return;
1993 }
Steve French50c2f752007-07-13 00:33:32 +00001994
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001995 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00001996 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001997
Steve French8af18972007-02-14 04:42:51 +00001998 /* check for reconnect case in which we do not
1999 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002000 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002001 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002002 originally at mount time */
2003 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2004 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002005 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2006 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2007 cERROR(1, ("POSIXPATH support change"));
Steve French8af18972007-02-14 04:42:51 +00002008 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002009 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2010 cERROR(1, ("possible reconnect error"));
2011 cERROR(1,
2012 ("server disabled POSIX path support"));
2013 }
Steve French8af18972007-02-14 04:42:51 +00002014 }
Steve French50c2f752007-07-13 00:33:32 +00002015
Steve French8af18972007-02-14 04:42:51 +00002016 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002017 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002018 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002019 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002020 cFYI(1, ("negotiated posix acl support"));
2021 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002022 sb->s_flags |= MS_POSIXACL;
2023 }
2024
Steve French75865f8c2007-06-24 18:30:48 +00002025 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002026 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002027 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002028 cFYI(1, ("negotiate posix pathnames"));
Steve French75865f8c2007-06-24 18:30:48 +00002029 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002030 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002031 CIFS_MOUNT_POSIX_PATHS;
2032 }
Steve French50c2f752007-07-13 00:33:32 +00002033
Steve French984acfe2007-04-26 16:42:50 +00002034 /* We might be setting the path sep back to a different
2035 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002036 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002037 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002038 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002039
2040 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2041 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2042 CIFS_SB(sb)->rsize = 127 * 1024;
Steve French90c81e02008-02-12 20:32:36 +00002043 cFYI(DBG2,
2044 ("larger reads not supported by srv"));
Steve French75865f8c2007-06-24 18:30:48 +00002045 }
2046 }
Steve French50c2f752007-07-13 00:33:32 +00002047
2048
2049 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
Steve French8af18972007-02-14 04:42:51 +00002050#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002051 if (cap & CIFS_UNIX_FCNTL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002052 cFYI(1, ("FCNTL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002053 if (cap & CIFS_UNIX_EXTATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002054 cFYI(1, ("EXTATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002055 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002056 cFYI(1, ("POSIX path cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002057 if (cap & CIFS_UNIX_XATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002058 cFYI(1, ("XATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002059 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002060 cFYI(1, ("POSIX ACL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002061 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002062 cFYI(1, ("very large read cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002063 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002064 cFYI(1, ("very large write cap"));
Steve French8af18972007-02-14 04:42:51 +00002065#endif /* CIFS_DEBUG2 */
2066 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002067 if (vol_info == NULL) {
Steve French5a44b312007-09-20 15:16:24 +00002068 cFYI(1, ("resetting capabilities failed"));
Steve French442aa312007-09-24 20:25:46 +00002069 } else
Steve French5a44b312007-09-20 15:16:24 +00002070 cERROR(1, ("Negotiating Unix capabilities "
2071 "with the server failed. Consider "
2072 "mounting with the Unix Extensions\n"
2073 "disabled, if problems are found, "
2074 "by specifying the nounix mount "
Steve French2224f4e2007-09-20 15:37:29 +00002075 "option."));
Steve French5a44b312007-09-20 15:16:24 +00002076
Steve French8af18972007-02-14 04:42:51 +00002077 }
2078 }
2079}
2080
Steve French03a143c2008-02-14 06:38:30 +00002081static void
2082convert_delimiter(char *path, char delim)
2083{
2084 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002085 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002086
2087 if (path == NULL)
2088 return;
2089
Steve French582d21e2008-05-13 04:54:12 +00002090 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002091 old_delim = '\\';
2092 else
2093 old_delim = '/';
2094
Steve French03a143c2008-02-14 06:38:30 +00002095 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002096 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002097 path[i] = delim;
2098 }
2099}
2100
Steve French3b795212008-11-13 19:45:32 +00002101static void setup_cifs_sb(struct smb_vol *pvolume_info,
2102 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002103{
Steve French3b795212008-11-13 19:45:32 +00002104 if (pvolume_info->rsize > CIFSMaxBufSize) {
2105 cERROR(1, ("rsize %d too large, using MaxBufSize",
2106 pvolume_info->rsize));
2107 cifs_sb->rsize = CIFSMaxBufSize;
2108 } else if ((pvolume_info->rsize) &&
2109 (pvolume_info->rsize <= CIFSMaxBufSize))
2110 cifs_sb->rsize = pvolume_info->rsize;
2111 else /* default */
2112 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002113
Steve French3b795212008-11-13 19:45:32 +00002114 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2115 cERROR(1, ("wsize %d too large, using 4096 instead",
2116 pvolume_info->wsize));
2117 cifs_sb->wsize = 4096;
2118 } else if (pvolume_info->wsize)
2119 cifs_sb->wsize = pvolume_info->wsize;
2120 else
2121 cifs_sb->wsize = min_t(const int,
2122 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2123 127*1024);
2124 /* old default of CIFSMaxBufSize was too small now
2125 that SMB Write2 can send multiple pages in kvec.
2126 RFC1001 does not describe what happens when frame
2127 bigger than 128K is sent so use that as max in
2128 conjunction with 52K kvec constraint on arch with 4K
2129 page size */
2130
2131 if (cifs_sb->rsize < 2048) {
2132 cifs_sb->rsize = 2048;
2133 /* Windows ME may prefer this */
2134 cFYI(1, ("readsize set to minimum: 2048"));
2135 }
2136 /* calculate prepath */
2137 cifs_sb->prepath = pvolume_info->prepath;
2138 if (cifs_sb->prepath) {
2139 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2140 /* we can not convert the / to \ in the path
2141 separators in the prefixpath yet because we do not
2142 know (until reset_cifs_unix_caps is called later)
2143 whether POSIX PATH CAP is available. We normalize
2144 the / to \ after reset_cifs_unix_caps is called */
2145 pvolume_info->prepath = NULL;
2146 } else
2147 cifs_sb->prepathlen = 0;
2148 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2149 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2150 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2151 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2152 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2153 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2154
2155 if (pvolume_info->noperm)
2156 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2157 if (pvolume_info->setuids)
2158 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2159 if (pvolume_info->server_ino)
2160 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2161 if (pvolume_info->remap)
2162 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2163 if (pvolume_info->no_xattr)
2164 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2165 if (pvolume_info->sfu_emul)
2166 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2167 if (pvolume_info->nobrl)
2168 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002169 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002170 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002171 if (pvolume_info->mand_lock)
2172 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002173 if (pvolume_info->cifs_acl)
2174 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2175 if (pvolume_info->override_uid)
2176 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2177 if (pvolume_info->override_gid)
2178 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2179 if (pvolume_info->dynperm)
2180 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2181 if (pvolume_info->direct_io) {
2182 cFYI(1, ("mounting share using direct i/o"));
2183 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2184 }
2185
2186 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2187 cERROR(1, ("mount option dynperm ignored if cifsacl "
2188 "mount option supported"));
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002189}
2190
Igor Mammedove4cce942009-02-10 14:10:26 +03002191static int
2192is_path_accessible(int xid, struct cifsTconInfo *tcon,
2193 struct cifs_sb_info *cifs_sb, const char *full_path)
2194{
2195 int rc;
2196 __u64 inode_num;
2197 FILE_ALL_INFO *pfile_info;
2198
2199 rc = CIFSGetSrvInodeNumber(xid, tcon, full_path, &inode_num,
2200 cifs_sb->local_nls,
2201 cifs_sb->mnt_cifs_flags &
2202 CIFS_MOUNT_MAP_SPECIAL_CHR);
2203 if (rc != -EOPNOTSUPP)
2204 return rc;
2205
2206 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2207 if (pfile_info == NULL)
2208 return -ENOMEM;
2209
2210 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2211 0 /* not legacy */, cifs_sb->local_nls,
2212 cifs_sb->mnt_cifs_flags &
2213 CIFS_MOUNT_MAP_SPECIAL_CHR);
2214 kfree(pfile_info);
2215 return rc;
2216}
2217
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002218static void
2219cleanup_volume_info(struct smb_vol **pvolume_info)
2220{
2221 struct smb_vol *volume_info;
2222
2223 if (!pvolume_info && !*pvolume_info)
2224 return;
2225
2226 volume_info = *pvolume_info;
2227 kzfree(volume_info->password);
2228 kfree(volume_info->UNC);
2229 kfree(volume_info->prepath);
2230 kfree(volume_info);
2231 *pvolume_info = NULL;
2232 return;
2233}
2234
Steve French2d6d5892009-04-09 00:36:44 +00002235#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002236/* build_path_to_root returns full path to root when
2237 * we do not have an exiting connection (tcon) */
2238static char *
2239build_unc_path_to_root(const struct smb_vol *volume_info,
2240 const struct cifs_sb_info *cifs_sb)
2241{
2242 char *full_path;
2243
2244 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2245 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2246 if (full_path == NULL)
2247 return ERR_PTR(-ENOMEM);
2248
2249 strncpy(full_path, volume_info->UNC, unc_len);
2250 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2251 int i;
2252 for (i = 0; i < unc_len; i++) {
2253 if (full_path[i] == '\\')
2254 full_path[i] = '/';
2255 }
2256 }
2257
2258 if (cifs_sb->prepathlen)
2259 strncpy(full_path + unc_len, cifs_sb->prepath,
2260 cifs_sb->prepathlen);
2261
2262 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2263 return full_path;
2264}
Steve French2d6d5892009-04-09 00:36:44 +00002265#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002266
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267int
2268cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002269 char *mount_data_global, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270{
2271 int rc = 0;
2272 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002273 struct smb_vol *volume_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 struct cifsSesInfo *pSesInfo = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 struct cifsTconInfo *tcon = NULL;
2276 struct TCP_Server_Info *srvTcp = NULL;
Igor Mammedove4cce942009-02-10 14:10:26 +03002277 char *full_path;
Steve French2d6d5892009-04-09 00:36:44 +00002278 char *mount_data = mount_data_global;
2279#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002280 struct dfs_info3_param *referrals = NULL;
2281 unsigned int num_referrals = 0;
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002282 int referral_walks_count = 0;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002283try_mount_again:
Steve French2d6d5892009-04-09 00:36:44 +00002284#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002285 full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286
2287 xid = GetXid();
2288
Jeff Layton7586b762008-12-01 18:41:49 -05002289 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2290 if (!volume_info) {
2291 rc = -ENOMEM;
2292 goto out;
2293 }
Steve French50c2f752007-07-13 00:33:32 +00002294
Jeff Layton7586b762008-12-01 18:41:49 -05002295 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002296 rc = -EINVAL;
2297 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 }
2299
Jeff Layton7586b762008-12-01 18:41:49 -05002300 if (volume_info->nullauth) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002301 cFYI(1, ("null user"));
Jeff Layton7586b762008-12-01 18:41:49 -05002302 volume_info->username = "";
2303 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 /* BB fixme parse for domain name here */
Jeff Layton7586b762008-12-01 18:41:49 -05002305 cFYI(1, ("Username: %s", volume_info->username));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002307 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002308 /* In userspace mount helper we can get user name from alternate
2309 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002310 rc = -EINVAL;
2311 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 }
2313
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314
2315 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002316 if (volume_info->iocharset == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 cifs_sb->local_nls = load_nls_default();
2318 /* load_nls_default can not return null */
2319 } else {
Jeff Layton7586b762008-12-01 18:41:49 -05002320 cifs_sb->local_nls = load_nls(volume_info->iocharset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002321 if (cifs_sb->local_nls == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002322 cERROR(1, ("CIFS mount error: iocharset %s not found",
Jeff Layton7586b762008-12-01 18:41:49 -05002323 volume_info->iocharset));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002324 rc = -ELIBACC;
2325 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 }
2327 }
2328
Jeff Layton63c038c2008-12-01 18:41:46 -05002329 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002330 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002331 if (IS_ERR(srvTcp)) {
2332 rc = PTR_ERR(srvTcp);
2333 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 }
2335
Jeff Layton7586b762008-12-01 18:41:49 -05002336 pSesInfo = cifs_find_smb_ses(srvTcp, volume_info->username);
Jeff Layton14fbf502008-11-14 13:53:46 -05002337 if (pSesInfo) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002338 cFYI(1, ("Existing smb sess found (status=%d)",
2339 pSesInfo->status));
Jeff Layton14fbf502008-11-14 13:53:46 -05002340 /*
2341 * The existing SMB session already has a reference to srvTcp,
2342 * so we can put back the extra one we got before
2343 */
2344 cifs_put_tcp_session(srvTcp);
2345
Steve French88e7d702008-01-03 17:37:09 +00002346 down(&pSesInfo->sesSem);
Steve French3b795212008-11-13 19:45:32 +00002347 if (pSesInfo->need_reconnect) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002348 cFYI(1, ("Session needs reconnect"));
Jeff Layton1d9a8852007-12-31 01:37:11 +00002349 rc = cifs_setup_session(xid, pSesInfo,
2350 cifs_sb->local_nls);
Jeff Layton1d9a8852007-12-31 01:37:11 +00002351 }
Steve French88e7d702008-01-03 17:37:09 +00002352 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 } else if (!rc) {
Steve Frenchbf820672005-12-01 22:32:42 -08002354 cFYI(1, ("Existing smb sess not found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 pSesInfo = sesInfoAlloc();
Jeff Layton14fbf502008-11-14 13:53:46 -05002356 if (pSesInfo == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 rc = -ENOMEM;
Jeff Layton14fbf502008-11-14 13:53:46 -05002358 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 }
2360
Jeff Layton14fbf502008-11-14 13:53:46 -05002361 /* new SMB session uses our srvTcp ref */
2362 pSesInfo->server = srvTcp;
Jeff Layton63c038c2008-12-01 18:41:46 -05002363 if (srvTcp->addr.sockAddr6.sin6_family == AF_INET6)
Linus Torvalds0191b622008-12-28 12:49:40 -08002364 sprintf(pSesInfo->serverName, "%pI6",
2365 &srvTcp->addr.sockAddr6.sin6_addr);
Jeff Layton8ecaf672008-12-01 15:23:50 -05002366 else
Linus Torvalds0191b622008-12-28 12:49:40 -08002367 sprintf(pSesInfo->serverName, "%pI4",
2368 &srvTcp->addr.sockAddr.sin_addr.s_addr);
Jeff Layton14fbf502008-11-14 13:53:46 -05002369
2370 write_lock(&cifs_tcp_ses_lock);
2371 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2372 write_unlock(&cifs_tcp_ses_lock);
2373
Jeff Layton7586b762008-12-01 18:41:49 -05002374 /* volume_info->password freed at unmount */
2375 if (volume_info->password) {
Jeff Layton00e485b2008-12-05 20:41:21 -05002376 pSesInfo->password = kstrdup(volume_info->password,
2377 GFP_KERNEL);
2378 if (!pSesInfo->password) {
2379 rc = -ENOMEM;
2380 goto mount_fail_check;
2381 }
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002382 }
Jeff Layton7586b762008-12-01 18:41:49 -05002383 if (volume_info->username)
2384 strncpy(pSesInfo->userName, volume_info->username,
Jeff Layton14fbf502008-11-14 13:53:46 -05002385 MAX_USERNAME_SIZE);
Jeff Layton7586b762008-12-01 18:41:49 -05002386 if (volume_info->domainname) {
2387 int len = strlen(volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002388 pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2389 if (pSesInfo->domainName)
2390 strcpy(pSesInfo->domainName,
Jeff Layton7586b762008-12-01 18:41:49 -05002391 volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002392 }
Jeff Layton7586b762008-12-01 18:41:49 -05002393 pSesInfo->linux_uid = volume_info->linux_uid;
2394 pSesInfo->overrideSecFlg = volume_info->secFlg;
Jeff Layton14fbf502008-11-14 13:53:46 -05002395 down(&pSesInfo->sesSem);
2396
2397 /* BB FIXME need to pass vol->secFlgs BB */
2398 rc = cifs_setup_session(xid, pSesInfo,
2399 cifs_sb->local_nls);
2400 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 }
Steve French50c2f752007-07-13 00:33:32 +00002402
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 /* search for existing tcon to this server share */
2404 if (!rc) {
Jeff Layton7586b762008-12-01 18:41:49 -05002405 setup_cifs_sb(volume_info, cifs_sb);
Steve French0ae0efa2005-10-10 10:57:19 -07002406
Jeff Layton7586b762008-12-01 18:41:49 -05002407 tcon = cifs_find_tcon(pSesInfo, volume_info->UNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 if (tcon) {
Steve Frenchbf820672005-12-01 22:32:42 -08002409 cFYI(1, ("Found match on UNC path"));
Jeff Laytonf1987b42008-11-15 11:12:47 -05002410 /* existing tcon already has a reference */
2411 cifs_put_smb_ses(pSesInfo);
Jeff Layton7586b762008-12-01 18:41:49 -05002412 if (tcon->seal != volume_info->seal)
Steve French95b1cb92008-05-15 16:44:38 +00002413 cERROR(1, ("transport encryption setting "
2414 "conflicts with existing tid"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 } else {
2416 tcon = tconInfoAlloc();
Steve French3b795212008-11-13 19:45:32 +00002417 if (tcon == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 rc = -ENOMEM;
Steve French3b795212008-11-13 19:45:32 +00002419 goto mount_fail_check;
2420 }
Jeff Layton00e485b2008-12-05 20:41:21 -05002421
Steve Frenchab3f9922008-11-17 16:03:00 +00002422 tcon->ses = pSesInfo;
Jeff Layton00e485b2008-12-05 20:41:21 -05002423 if (volume_info->password) {
2424 tcon->password = kstrdup(volume_info->password,
2425 GFP_KERNEL);
2426 if (!tcon->password) {
2427 rc = -ENOMEM;
2428 goto mount_fail_check;
2429 }
2430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431
Jeff Layton7586b762008-12-01 18:41:49 -05002432 if ((strchr(volume_info->UNC + 3, '\\') == NULL)
2433 && (strchr(volume_info->UNC + 3, '/') == NULL)) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002434 cERROR(1, ("Missing share name"));
Steve French3b795212008-11-13 19:45:32 +00002435 rc = -ENODEV;
2436 goto mount_fail_check;
2437 } else {
2438 /* BB Do we need to wrap sesSem around
2439 * this TCon call and Unix SetFS as
2440 * we do on SessSetup and reconnect? */
Jeff Layton7586b762008-12-01 18:41:49 -05002441 rc = CIFSTCon(xid, pSesInfo, volume_info->UNC,
Steve French3b795212008-11-13 19:45:32 +00002442 tcon, cifs_sb->local_nls);
2443 cFYI(1, ("CIFS Tcon rc = %d", rc));
Jeff Layton7586b762008-12-01 18:41:49 -05002444 if (volume_info->nodfs) {
Steve French3b795212008-11-13 19:45:32 +00002445 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2446 cFYI(1, ("DFS disabled (%d)",
2447 tcon->Flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 }
2449 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002450 if (rc)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002451 goto remote_path_check;
Jeff Layton7586b762008-12-01 18:41:49 -05002452 tcon->seal = volume_info->seal;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002453 write_lock(&cifs_tcp_ses_lock);
2454 list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2455 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 }
Steve French3b795212008-11-13 19:45:32 +00002457
2458 /* we can have only one retry value for a connection
2459 to a share so for resources mounted more than once
2460 to the same server share the last value passed in
2461 for the retry flag is used */
Jeff Layton7586b762008-12-01 18:41:49 -05002462 tcon->retry = volume_info->retry;
2463 tcon->nocase = volume_info->nocase;
2464 tcon->local_lease = volume_info->local_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
Steve French4523cc32007-04-30 20:13:06 +00002466 if (pSesInfo) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2468 sb->s_maxbytes = (u64) 1 << 63;
2469 } else
2470 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2471 }
2472
Steve French8af18972007-02-14 04:42:51 +00002473 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 sb->s_time_gran = 100;
2475
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002476 if (rc)
2477 goto remote_path_check;
2478
Steve Frenchd82c2df2008-11-15 00:07:26 +00002479 cifs_sb->tcon = tcon;
Steve Frenchd82c2df2008-11-15 00:07:26 +00002480
2481 /* do not care if following two calls succeed - informational */
2482 if (!tcon->ipc) {
2483 CIFSSMBQFSDeviceInfo(xid, tcon);
2484 CIFSSMBQFSAttributeInfo(xid, tcon);
2485 }
2486
2487 /* tell server which Unix caps we support */
2488 if (tcon->ses->capabilities & CAP_UNIX)
2489 /* reset of caps checks mount to see if unix extensions
2490 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002491 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002492 else
2493 tcon->unix_ext = 0; /* server does not support them */
2494
2495 /* convert forward to back slashes in prepath here if needed */
2496 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2497 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2498
2499 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2500 cifs_sb->rsize = 1024 * 127;
2501 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2502 }
2503 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2504 cifs_sb->wsize = min(cifs_sb->wsize,
2505 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2506 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2507 cifs_sb->rsize = min(cifs_sb->rsize,
2508 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002510remote_path_check:
2511 /* check if a whole path (including prepath) is not remote */
2512 if (!rc && cifs_sb->prepathlen && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002513 /* build_path_to_root works only when we have a valid tcon */
2514 full_path = cifs_build_path_to_root(cifs_sb);
2515 if (full_path == NULL) {
2516 rc = -ENOMEM;
2517 goto mount_fail_check;
2518 }
2519 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002520 if (rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002521 kfree(full_path);
2522 goto mount_fail_check;
2523 }
2524 kfree(full_path);
2525 }
2526
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002527 /* get referral if needed */
2528 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00002529#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002530 if (referral_walks_count > MAX_NESTED_LINKS) {
2531 /*
2532 * BB: when we implement proper loop detection,
2533 * we will remove this check. But now we need it
2534 * to prevent an indefinite loop if 'DFS tree' is
2535 * misconfigured (i.e. has loops).
2536 */
2537 rc = -ELOOP;
2538 goto mount_fail_check;
2539 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002540 /* convert forward to back slashes in prepath here if needed */
2541 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2542 convert_delimiter(cifs_sb->prepath,
2543 CIFS_DIR_SEP(cifs_sb));
2544 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2545 if (IS_ERR(full_path)) {
2546 rc = PTR_ERR(full_path);
2547 goto mount_fail_check;
2548 }
2549
2550 cFYI(1, ("Getting referral for: %s", full_path));
2551 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2552 cifs_sb->local_nls, &num_referrals, &referrals,
2553 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2554 if (!rc && num_referrals > 0) {
2555 char *fake_devname = NULL;
2556
2557 if (mount_data != mount_data_global)
2558 kfree(mount_data);
2559 mount_data = cifs_compose_mount_options(
2560 cifs_sb->mountdata, full_path + 1,
2561 referrals, &fake_devname);
2562 kfree(fake_devname);
2563 free_dfs_info_array(referrals, num_referrals);
2564
2565 if (tcon)
2566 cifs_put_tcon(tcon);
2567 else if (pSesInfo)
2568 cifs_put_smb_ses(pSesInfo);
2569
2570 cleanup_volume_info(&volume_info);
2571 FreeXid(xid);
2572 kfree(full_path);
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002573 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002574 goto try_mount_again;
2575 }
Steve Frenchd036f502009-04-03 03:12:08 +00002576#else /* No DFS support, return error on mount */
2577 rc = -EOPNOTSUPP;
2578#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002579 }
2580
2581mount_fail_check:
2582 /* on error free sesinfo and tcon struct if needed */
2583 if (rc) {
2584 if (mount_data != mount_data_global)
2585 kfree(mount_data);
2586 /* If find_unc succeeded then rc == 0 so we can not end */
2587 /* up accidently freeing someone elses tcon struct */
2588 if (tcon)
2589 cifs_put_tcon(tcon);
2590 else if (pSesInfo)
2591 cifs_put_smb_ses(pSesInfo);
2592 else
2593 cifs_put_tcp_session(srvTcp);
2594 goto out;
2595 }
2596
Jeff Layton7586b762008-12-01 18:41:49 -05002597 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 (in which case it is not needed anymore) but when new sesion is created
2599 the password ptr is put in the new session structure (in which case the
2600 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002601out:
2602 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002603 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 FreeXid(xid);
2605 return rc;
2606}
2607
2608static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
Steve French4b18f2a2008-04-29 00:06:05 +00002610 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 const struct nls_table *nls_codepage)
2612{
2613 struct smb_hdr *smb_buffer;
2614 struct smb_hdr *smb_buffer_response;
2615 SESSION_SETUP_ANDX *pSMB;
2616 SESSION_SETUP_ANDX *pSMBr;
2617 char *bcc_ptr;
2618 char *domain;
2619 int rc = 0;
2620 int remaining_words = 0;
2621 int bytes_returned = 0;
2622 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002623 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 PNEGOTIATE_MESSAGE SecurityBlob;
2625 PCHALLENGE_MESSAGE SecurityBlob2;
2626 __u32 negotiate_flags, capabilities;
2627 __u16 count;
2628
Steve French12b3b8f2006-02-09 21:12:47 +00002629 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002630 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 return -EINVAL;
2632 domain = ses->domainName;
Steve French4b18f2a2008-04-29 00:06:05 +00002633 *pNTLMv2_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634 smb_buffer = cifs_buf_get();
2635 if (smb_buffer == NULL) {
2636 return -ENOMEM;
2637 }
2638 smb_buffer_response = smb_buffer;
2639 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2640 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2641
2642 /* send SMBsessionSetup here */
2643 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2644 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002645
2646 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2648 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2649
2650 pSMB->req.AndXCommand = 0xFF;
2651 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2652 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2653
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002654 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2656
2657 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2658 CAP_EXTENDED_SECURITY;
2659 if (ses->capabilities & CAP_UNICODE) {
2660 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2661 capabilities |= CAP_UNICODE;
2662 }
2663 if (ses->capabilities & CAP_STATUS32) {
2664 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2665 capabilities |= CAP_STATUS32;
2666 }
2667 if (ses->capabilities & CAP_DFS) {
2668 smb_buffer->Flags2 |= SMBFLG2_DFS;
2669 capabilities |= CAP_DFS;
2670 }
2671 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2672
2673 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2674 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2675 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2676 SecurityBlob->MessageType = NtLmNegotiate;
2677 negotiate_flags =
2678 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
Steve French12b3b8f2006-02-09 21:12:47 +00002679 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2680 NTLMSSP_NEGOTIATE_56 |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002682 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002684/* if (ntlmv2_support)
Steve French39798772006-05-31 22:40:51 +00002685 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 /* setup pointers to domain name and workstation name */
2687 bcc_ptr += SecurityBlobLength;
2688
2689 SecurityBlob->WorkstationName.Buffer = 0;
2690 SecurityBlob->WorkstationName.Length = 0;
2691 SecurityBlob->WorkstationName.MaximumLength = 0;
2692
Steve French12b3b8f2006-02-09 21:12:47 +00002693 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2694 along with username on auth request (ie the response to challenge) */
2695 SecurityBlob->DomainName.Buffer = 0;
2696 SecurityBlob->DomainName.Length = 0;
2697 SecurityBlob->DomainName.MaximumLength = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 if (ses->capabilities & CAP_UNICODE) {
2699 if ((long) bcc_ptr % 2) {
2700 *bcc_ptr = 0;
2701 bcc_ptr++;
2702 }
2703
2704 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002705 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 32, nls_codepage);
2707 bcc_ptr += 2 * bytes_returned;
2708 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002709 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 nls_codepage);
2711 bcc_ptr += 2 * bytes_returned;
2712 bcc_ptr += 2; /* null terminate Linux version */
2713 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002714 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 64, nls_codepage);
2716 bcc_ptr += 2 * bytes_returned;
2717 *(bcc_ptr + 1) = 0;
2718 *(bcc_ptr + 2) = 0;
2719 bcc_ptr += 2; /* null terminate network opsys string */
2720 *(bcc_ptr + 1) = 0;
2721 *(bcc_ptr + 2) = 0;
2722 bcc_ptr += 2; /* null domain */
2723 } else { /* ASCII */
2724 strcpy(bcc_ptr, "Linux version ");
2725 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002726 strcpy(bcc_ptr, utsname()->release);
2727 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2729 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2730 bcc_ptr++; /* empty domain field */
2731 *bcc_ptr = 0;
2732 }
2733 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2734 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2735 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2736 smb_buffer->smb_buf_length += count;
2737 pSMB->req.ByteCount = cpu_to_le16(count);
2738
2739 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00002740 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741
2742 if (smb_buffer_response->Status.CifsError ==
2743 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2744 rc = 0;
2745
2746 if (rc) {
2747/* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2748 } else if ((smb_buffer_response->WordCount == 3)
2749 || (smb_buffer_response->WordCount == 4)) {
2750 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2751 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2752
2753 if (action & GUEST_LOGIN)
Steve French61e74802008-12-03 00:57:54 +00002754 cFYI(1, ("Guest login"));
Steve French50c2f752007-07-13 00:33:32 +00002755 /* Do we want to set anything in SesInfo struct when guest login? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756
Steve French50c2f752007-07-13 00:33:32 +00002757 bcc_ptr = pByteArea(smb_buffer_response);
2758 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759
2760 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2761 if (SecurityBlob2->MessageType != NtLmChallenge) {
Steve French61e74802008-12-03 00:57:54 +00002762 cFYI(1, ("Unexpected NTLMSSP message type received %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 SecurityBlob2->MessageType));
2764 } else if (ses) {
Steve French50c2f752007-07-13 00:33:32 +00002765 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
Steve French12b3b8f2006-02-09 21:12:47 +00002766 cFYI(1, ("UID = %d", ses->Suid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 if ((pSMBr->resp.hdr.WordCount == 3)
2768 || ((pSMBr->resp.hdr.WordCount == 4)
2769 && (blob_len <
2770 pSMBr->resp.ByteCount))) {
2771
2772 if (pSMBr->resp.hdr.WordCount == 4) {
2773 bcc_ptr += blob_len;
Steve French12b3b8f2006-02-09 21:12:47 +00002774 cFYI(1, ("Security Blob Length %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775 blob_len));
2776 }
2777
Steve French12b3b8f2006-02-09 21:12:47 +00002778 cFYI(1, ("NTLMSSP Challenge rcvd"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779
2780 memcpy(ses->server->cryptKey,
2781 SecurityBlob2->Challenge,
2782 CIFS_CRYPTO_KEY_SIZE);
Steve French50c2f752007-07-13 00:33:32 +00002783 if (SecurityBlob2->NegotiateFlags &
Steve French12b3b8f2006-02-09 21:12:47 +00002784 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
Steve French4b18f2a2008-04-29 00:06:05 +00002785 *pNTLMv2_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786
Steve French50c2f752007-07-13 00:33:32 +00002787 if ((SecurityBlob2->NegotiateFlags &
2788 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 || (sign_CIFS_PDUs > 1))
Steve French50c2f752007-07-13 00:33:32 +00002790 ses->server->secMode |=
2791 SECMODE_SIGN_REQUIRED;
2792 if ((SecurityBlob2->NegotiateFlags &
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
Steve French50c2f752007-07-13 00:33:32 +00002794 ses->server->secMode |=
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 SECMODE_SIGN_ENABLED;
2796
2797 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2798 if ((long) (bcc_ptr) % 2) {
2799 remaining_words =
2800 (BCC(smb_buffer_response)
2801 - 1) / 2;
Steve French50c2f752007-07-13 00:33:32 +00002802 /* Must word align unicode strings */
2803 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 } else {
2805 remaining_words =
2806 BCC
2807 (smb_buffer_response) / 2;
2808 }
2809 len =
2810 UniStrnlen((wchar_t *) bcc_ptr,
2811 remaining_words - 1);
2812/* We look for obvious messed up bcc or strings in response so we do not go off
2813 the end since (at least) WIN2K and Windows XP have a major bug in not null
2814 terminating last Unicode string in response */
Wei Yongjun74496d32009-03-31 16:28:36 +08002815 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002817 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08002819 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 bcc_ptr, len,
2821 nls_codepage);
2822 bcc_ptr += 2 * (len + 1);
2823 remaining_words -= len + 1;
2824 ses->serverOS[2 * len] = 0;
2825 ses->serverOS[1 + (2 * len)] = 0;
2826 if (remaining_words > 0) {
2827 len = UniStrnlen((wchar_t *)
2828 bcc_ptr,
2829 remaining_words
2830 - 1);
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 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 GFP_KERNEL);
2835 cifs_strfromUCS_le(ses->
2836 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08002837 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 bcc_ptr,
2839 len,
2840 nls_codepage);
2841 bcc_ptr += 2 * (len + 1);
2842 ses->serverNOS[2 * len] = 0;
2843 ses->serverNOS[1 +
2844 (2 * len)] = 0;
2845 remaining_words -= len + 1;
2846 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00002847 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2848 /* last string not always null terminated
2849 (for e.g. for Windows XP & 2000) */
Steve Frenchcd49b492006-06-26 04:22:36 +00002850 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002852 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 (len +
2854 1),
2855 GFP_KERNEL);
2856 cifs_strfromUCS_le
Steve Frenche89dc922005-11-11 15:18:19 -08002857 (ses->serverDomain,
2858 (__le16 *)bcc_ptr,
2859 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 bcc_ptr +=
2861 2 * (len + 1);
Steve Frenche89dc922005-11-11 15:18:19 -08002862 ses->serverDomain[2*len]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 = 0;
Steve Frenche89dc922005-11-11 15:18:19 -08002864 ses->serverDomain
2865 [1 + (2 * len)]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 = 0;
2867 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00002868 else {
Steve Frenchcd49b492006-06-26 04:22:36 +00002869 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002871 kzalloc(2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00002873 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 } else { /* no room so create dummy domain and NOS string */
Steve Frenchcd49b492006-06-26 04:22:36 +00002875 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002877 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00002878 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002880 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 }
2882 } else { /* ASCII */
2883 len = strnlen(bcc_ptr, 1024);
2884 if (((long) bcc_ptr + len) - (long)
2885 pByteArea(smb_buffer_response)
2886 <= BCC(smb_buffer_response)) {
Wei Yongjun74496d32009-03-31 16:28:36 +08002887 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002889 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 GFP_KERNEL);
2891 strncpy(ses->serverOS,
2892 bcc_ptr, len);
2893
2894 bcc_ptr += len;
2895 bcc_ptr[0] = 0; /* null terminate string */
2896 bcc_ptr++;
2897
2898 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002899 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002901 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 GFP_KERNEL);
2903 strncpy(ses->serverNOS, bcc_ptr, len);
2904 bcc_ptr += len;
2905 bcc_ptr[0] = 0;
2906 bcc_ptr++;
2907
2908 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002909 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002911 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +00002913 strncpy(ses->serverDomain,
2914 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 bcc_ptr += len;
2916 bcc_ptr[0] = 0;
2917 bcc_ptr++;
2918 } else
2919 cFYI(1,
Steve French63135e02007-07-17 17:34:02 +00002920 ("field of length %d "
2921 "extends beyond end of smb",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922 len));
2923 }
2924 } else {
Steve French50c2f752007-07-13 00:33:32 +00002925 cERROR(1, ("Security Blob Length extends beyond"
2926 " end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 }
2928 } else {
2929 cERROR(1, ("No session structure passed in."));
2930 }
2931 } else {
Steve French61e74802008-12-03 00:57:54 +00002932 cERROR(1, ("Invalid Word count %d:",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 smb_buffer_response->WordCount));
2934 rc = -EIO;
2935 }
2936
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002937 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938
2939 return rc;
2940}
Steve French20418ac2009-04-30 16:13:32 +00002941
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942static int
2943CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Steve French4b18f2a2008-04-29 00:06:05 +00002944 char *ntlm_session_key, bool ntlmv2_flag,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002945 const struct nls_table *nls_codepage)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946{
2947 struct smb_hdr *smb_buffer;
2948 struct smb_hdr *smb_buffer_response;
2949 SESSION_SETUP_ANDX *pSMB;
2950 SESSION_SETUP_ANDX *pSMBr;
2951 char *bcc_ptr;
2952 char *user;
2953 char *domain;
2954 int rc = 0;
2955 int remaining_words = 0;
2956 int bytes_returned = 0;
2957 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002958 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 PAUTHENTICATE_MESSAGE SecurityBlob;
2960 __u32 negotiate_flags, capabilities;
2961 __u16 count;
2962
2963 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002964 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 return -EINVAL;
2966 user = ses->userName;
2967 domain = ses->domainName;
2968 smb_buffer = cifs_buf_get();
2969 if (smb_buffer == NULL) {
2970 return -ENOMEM;
2971 }
2972 smb_buffer_response = smb_buffer;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002973 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2974 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975
2976 /* send SMBsessionSetup here */
2977 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2978 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002979
2980 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2982 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2983 pSMB->req.AndXCommand = 0xFF;
2984 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2985 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2986
2987 pSMB->req.hdr.Uid = ses->Suid;
2988
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002989 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2991
2992 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002993 CAP_EXTENDED_SECURITY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994 if (ses->capabilities & CAP_UNICODE) {
2995 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2996 capabilities |= CAP_UNICODE;
2997 }
2998 if (ses->capabilities & CAP_STATUS32) {
2999 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3000 capabilities |= CAP_STATUS32;
3001 }
3002 if (ses->capabilities & CAP_DFS) {
3003 smb_buffer->Flags2 |= SMBFLG2_DFS;
3004 capabilities |= CAP_DFS;
3005 }
3006 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3007
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003008 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3009 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3011 SecurityBlob->MessageType = NtLmAuthenticate;
3012 bcc_ptr += SecurityBlobLength;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003013 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3014 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3015 0x80000000 | NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003016 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003018 if (ntlmv2_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3020
3021/* setup pointers to domain name and workstation name */
3022
3023 SecurityBlob->WorkstationName.Buffer = 0;
3024 SecurityBlob->WorkstationName.Length = 0;
3025 SecurityBlob->WorkstationName.MaximumLength = 0;
3026 SecurityBlob->SessionKey.Length = 0;
3027 SecurityBlob->SessionKey.MaximumLength = 0;
3028 SecurityBlob->SessionKey.Buffer = 0;
3029
3030 SecurityBlob->LmChallengeResponse.Length = 0;
3031 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3032 SecurityBlob->LmChallengeResponse.Buffer = 0;
3033
3034 SecurityBlob->NtChallengeResponse.Length =
Steve French7c7b25b2006-06-01 19:20:10 +00003035 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 SecurityBlob->NtChallengeResponse.MaximumLength =
Steve French7c7b25b2006-06-01 19:20:10 +00003037 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3038 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 SecurityBlob->NtChallengeResponse.Buffer =
3040 cpu_to_le32(SecurityBlobLength);
Steve French7c7b25b2006-06-01 19:20:10 +00003041 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3042 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043
3044 if (ses->capabilities & CAP_UNICODE) {
3045 if (domain == NULL) {
3046 SecurityBlob->DomainName.Buffer = 0;
3047 SecurityBlob->DomainName.Length = 0;
3048 SecurityBlob->DomainName.MaximumLength = 0;
3049 } else {
Steve French77159b42007-08-31 01:10:17 +00003050 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003052 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003054 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 SecurityBlob->DomainName.Buffer =
3056 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003057 bcc_ptr += ln;
3058 SecurityBlobLength += ln;
3059 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060 }
3061 if (user == NULL) {
3062 SecurityBlob->UserName.Buffer = 0;
3063 SecurityBlob->UserName.Length = 0;
3064 SecurityBlob->UserName.MaximumLength = 0;
3065 } else {
Steve French77159b42007-08-31 01:10:17 +00003066 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003068 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003069 SecurityBlob->UserName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003070 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071 SecurityBlob->UserName.Buffer =
3072 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003073 bcc_ptr += ln;
3074 SecurityBlobLength += ln;
3075 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 }
3077
Steve French63135e02007-07-17 17:34:02 +00003078 /* SecurityBlob->WorkstationName.Length =
3079 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 SecurityBlob->WorkstationName.Length *= 2;
Steve French63135e02007-07-17 17:34:02 +00003081 SecurityBlob->WorkstationName.MaximumLength =
3082 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3083 SecurityBlob->WorkstationName.Buffer =
3084 cpu_to_le32(SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 bcc_ptr += SecurityBlob->WorkstationName.Length;
3086 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
Steve French63135e02007-07-17 17:34:02 +00003087 SecurityBlob->WorkstationName.Length =
3088 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089
3090 if ((long) bcc_ptr % 2) {
3091 *bcc_ptr = 0;
3092 bcc_ptr++;
3093 }
3094 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003095 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 32, nls_codepage);
3097 bcc_ptr += 2 * bytes_returned;
3098 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003099 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 nls_codepage);
3101 bcc_ptr += 2 * bytes_returned;
3102 bcc_ptr += 2; /* null term version string */
3103 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003104 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 64, nls_codepage);
3106 bcc_ptr += 2 * bytes_returned;
3107 *(bcc_ptr + 1) = 0;
3108 *(bcc_ptr + 2) = 0;
3109 bcc_ptr += 2; /* null terminate network opsys string */
3110 *(bcc_ptr + 1) = 0;
3111 *(bcc_ptr + 2) = 0;
3112 bcc_ptr += 2; /* null domain */
3113 } else { /* ASCII */
3114 if (domain == NULL) {
3115 SecurityBlob->DomainName.Buffer = 0;
3116 SecurityBlob->DomainName.Length = 0;
3117 SecurityBlob->DomainName.MaximumLength = 0;
3118 } else {
Steve French77159b42007-08-31 01:10:17 +00003119 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003120 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3121 strncpy(bcc_ptr, domain, 63);
Steve French77159b42007-08-31 01:10:17 +00003122 ln = strnlen(domain, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003124 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 SecurityBlob->DomainName.Buffer =
3126 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003127 bcc_ptr += ln;
3128 SecurityBlobLength += ln;
3129 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130 }
3131 if (user == NULL) {
3132 SecurityBlob->UserName.Buffer = 0;
3133 SecurityBlob->UserName.Length = 0;
3134 SecurityBlob->UserName.MaximumLength = 0;
3135 } else {
Steve French77159b42007-08-31 01:10:17 +00003136 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 strncpy(bcc_ptr, user, 63);
Steve French77159b42007-08-31 01:10:17 +00003138 ln = strnlen(user, 64);
3139 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 SecurityBlob->UserName.Buffer =
Steve French77159b42007-08-31 01:10:17 +00003141 cpu_to_le32(SecurityBlobLength);
3142 bcc_ptr += ln;
3143 SecurityBlobLength += ln;
3144 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145 }
3146 /* BB fill in our workstation name if known BB */
3147
3148 strcpy(bcc_ptr, "Linux version ");
3149 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003150 strcpy(bcc_ptr, utsname()->release);
3151 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3153 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3154 bcc_ptr++; /* null domain */
3155 *bcc_ptr = 0;
3156 }
3157 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3158 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3159 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3160 smb_buffer->smb_buf_length += count;
3161 pSMB->req.ByteCount = cpu_to_le16(count);
3162
3163 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00003164 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165 if (rc) {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003166/* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3167 } else if ((smb_buffer_response->WordCount == 3) ||
3168 (smb_buffer_response->WordCount == 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 __u16 action = le16_to_cpu(pSMBr->resp.Action);
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003170 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 if (action & GUEST_LOGIN)
Steve French61e74802008-12-03 00:57:54 +00003172 cFYI(1, ("Guest login")); /* BB Should we set anything
Steve French50c2f752007-07-13 00:33:32 +00003173 in SesInfo struct ? */
3174/* if (SecurityBlob2->MessageType != NtLm??) {
3175 cFYI("Unexpected message type on auth response is %d"));
3176 } */
3177
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 if (ses) {
3179 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00003180 ("Check challenge UID %d vs auth response UID %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181 ses->Suid, smb_buffer_response->Uid));
Steve French50c2f752007-07-13 00:33:32 +00003182 /* UID left in wire format */
3183 ses->Suid = smb_buffer_response->Uid;
3184 bcc_ptr = pByteArea(smb_buffer_response);
3185 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186 if ((pSMBr->resp.hdr.WordCount == 3)
3187 || ((pSMBr->resp.hdr.WordCount == 4)
3188 && (blob_len <
3189 pSMBr->resp.ByteCount))) {
3190 if (pSMBr->resp.hdr.WordCount == 4) {
3191 bcc_ptr +=
3192 blob_len;
3193 cFYI(1,
3194 ("Security Blob Length %d ",
3195 blob_len));
3196 }
3197
3198 cFYI(1,
3199 ("NTLMSSP response to Authenticate "));
3200
3201 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3202 if ((long) (bcc_ptr) % 2) {
3203 remaining_words =
3204 (BCC(smb_buffer_response)
3205 - 1) / 2;
3206 bcc_ptr++; /* Unicode strings must be word aligned */
3207 } else {
3208 remaining_words = BCC(smb_buffer_response) / 2;
3209 }
Steve French77159b42007-08-31 01:10:17 +00003210 len = UniStrnlen((wchar_t *) bcc_ptr,
3211 remaining_words - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212/* We look for obvious messed up bcc or strings in response so we do not go off
3213 the end since (at least) WIN2K and Windows XP have a major bug in not null
3214 terminating last Unicode string in response */
Wei Yongjun74496d32009-03-31 16:28:36 +08003215 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003217 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003219 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220 bcc_ptr, len,
3221 nls_codepage);
3222 bcc_ptr += 2 * (len + 1);
3223 remaining_words -= len + 1;
3224 ses->serverOS[2 * len] = 0;
3225 ses->serverOS[1 + (2 * len)] = 0;
3226 if (remaining_words > 0) {
3227 len = UniStrnlen((wchar_t *)
3228 bcc_ptr,
3229 remaining_words
3230 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00003231 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003233 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234 GFP_KERNEL);
3235 cifs_strfromUCS_le(ses->
3236 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003237 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 bcc_ptr,
3239 len,
3240 nls_codepage);
3241 bcc_ptr += 2 * (len + 1);
3242 ses->serverNOS[2 * len] = 0;
3243 ses->serverNOS[1+(2*len)] = 0;
3244 remaining_words -= len + 1;
3245 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00003246 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 /* last string not always null terminated (e.g. for Windows XP & 2000) */
Wei Yongjun74496d32009-03-31 16:28:36 +08003248 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003250 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 (len +
3252 1),
3253 GFP_KERNEL);
3254 cifs_strfromUCS_le
3255 (ses->
3256 serverDomain,
Steve Frenche89dc922005-11-11 15:18:19 -08003257 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 bcc_ptr, len,
3259 nls_codepage);
3260 bcc_ptr +=
3261 2 * (len + 1);
3262 ses->
3263 serverDomain[2
3264 * len]
3265 = 0;
3266 ses->
3267 serverDomain[1
3268 +
3269 (2
3270 *
3271 len)]
3272 = 0;
3273 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00003274 else {
Wei Yongjun74496d32009-03-31 16:28:36 +08003275 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003276 ses->serverDomain = kzalloc(2,GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00003277 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 } else { /* no room so create dummy domain and NOS string */
Wei Yongjun74496d32009-03-31 16:28:36 +08003279 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003280 ses->serverDomain = kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00003281 kfree(ses->serverNOS);
Pekka Enberge915fc42005-09-06 15:18:35 -07003282 ses->serverNOS = kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003283 }
3284 } else { /* ASCII */
3285 len = strnlen(bcc_ptr, 1024);
Steve French50c2f752007-07-13 00:33:32 +00003286 if (((long) bcc_ptr + len) -
3287 (long) pByteArea(smb_buffer_response)
Steve French63135e02007-07-17 17:34:02 +00003288 <= BCC(smb_buffer_response)) {
Wei Yongjun74496d32009-03-31 16:28:36 +08003289 kfree(ses->serverOS);
Steve French77159b42007-08-31 01:10:17 +00003290 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291 strncpy(ses->serverOS,bcc_ptr, len);
3292
3293 bcc_ptr += len;
3294 bcc_ptr[0] = 0; /* null terminate the string */
3295 bcc_ptr++;
3296
3297 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00003298 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00003299 ses->serverNOS = kzalloc(len+1,
3300 GFP_KERNEL);
Steve French63135e02007-07-17 17:34:02 +00003301 strncpy(ses->serverNOS,
3302 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303 bcc_ptr += len;
3304 bcc_ptr[0] = 0;
3305 bcc_ptr++;
3306
3307 len = strnlen(bcc_ptr, 1024);
Wei Yongjun74496d32009-03-31 16:28:36 +08003308 kfree(ses->serverDomain);
Steve French63135e02007-07-17 17:34:02 +00003309 ses->serverDomain =
3310 kzalloc(len+1,
3311 GFP_KERNEL);
3312 strncpy(ses->serverDomain,
3313 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 bcc_ptr += len;
3315 bcc_ptr[0] = 0;
3316 bcc_ptr++;
3317 } else
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003318 cFYI(1, ("field of length %d "
Steve French63135e02007-07-17 17:34:02 +00003319 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 len));
3321 }
3322 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003323 cERROR(1, ("Security Blob extends beyond end "
Steve French63135e02007-07-17 17:34:02 +00003324 "of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325 }
3326 } else {
3327 cERROR(1, ("No session structure passed in."));
3328 }
3329 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003330 cERROR(1, ("Invalid Word count %d: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331 smb_buffer_response->WordCount));
3332 rc = -EIO;
3333 }
3334
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003335 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003336
3337 return rc;
3338}
3339
3340int
3341CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3342 const char *tree, struct cifsTconInfo *tcon,
3343 const struct nls_table *nls_codepage)
3344{
3345 struct smb_hdr *smb_buffer;
3346 struct smb_hdr *smb_buffer_response;
3347 TCONX_REQ *pSMB;
3348 TCONX_RSP *pSMBr;
3349 unsigned char *bcc_ptr;
3350 int rc = 0;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003351 int length, bytes_left;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352 __u16 count;
3353
3354 if (ses == NULL)
3355 return -EIO;
3356
3357 smb_buffer = cifs_buf_get();
3358 if (smb_buffer == NULL) {
3359 return -ENOMEM;
3360 }
3361 smb_buffer_response = smb_buffer;
3362
3363 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3364 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003365
3366 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003367 smb_buffer->Uid = ses->Suid;
3368 pSMB = (TCONX_REQ *) smb_buffer;
3369 pSMBr = (TCONX_RSP *) smb_buffer_response;
3370
3371 pSMB->AndXCommand = 0xFF;
3372 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003374 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08003375 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003376 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003377 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003378 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003379 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00003380 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003381 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3382 specified as required (when that support is added to
3383 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003384 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003385 by Samba (not sure whether other servers allow
3386 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003387#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French50c2f752007-07-13 00:33:32 +00003388 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003389 (ses->server->secType == LANMAN))
3390 calc_lanman_hash(tcon->password, ses->server->cryptKey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003391 ses->server->secMode &
3392 SECMODE_PW_ENCRYPT ? true : false,
3393 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003394 else
3395#endif /* CIFS_WEAK_PW_HASH */
Jeff Layton00e485b2008-12-05 20:41:21 -05003396 SMBNTencrypt(tcon->password, ses->server->cryptKey,
Steve Frencheeac8042006-01-13 21:34:58 -08003397 bcc_ptr);
3398
Steve French7c7b25b2006-06-01 19:20:10 +00003399 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003400 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003401 /* must align unicode strings */
3402 *bcc_ptr = 0; /* null byte password */
3403 bcc_ptr++;
3404 }
Steve Frencheeac8042006-01-13 21:34:58 -08003405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406
Steve French50c2f752007-07-13 00:33:32 +00003407 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003408 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3410
3411 if (ses->capabilities & CAP_STATUS32) {
3412 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3413 }
3414 if (ses->capabilities & CAP_DFS) {
3415 smb_buffer->Flags2 |= SMBFLG2_DFS;
3416 }
3417 if (ses->capabilities & CAP_UNICODE) {
3418 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3419 length =
Steve French50c2f752007-07-13 00:33:32 +00003420 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3421 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003422 (/* server len*/ + 256 /* share len */), nls_codepage);
3423 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424 bcc_ptr += 2; /* skip trailing null */
3425 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 strcpy(bcc_ptr, tree);
3427 bcc_ptr += strlen(tree) + 1;
3428 }
3429 strcpy(bcc_ptr, "?????");
3430 bcc_ptr += strlen("?????");
3431 bcc_ptr += 1;
3432 count = bcc_ptr - &pSMB->Password[0];
3433 pSMB->hdr.smb_buf_length += count;
3434 pSMB->ByteCount = cpu_to_le16(count);
3435
Steve French133672e2007-11-13 22:41:37 +00003436 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3437 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438
Linus Torvalds1da177e2005-04-16 15:20:36 -07003439 /* above now done in SendReceive */
3440 if ((rc == 0) && (tcon != NULL)) {
3441 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003442 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443 tcon->tid = smb_buffer_response->Tid;
3444 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003445 bytes_left = BCC(smb_buffer_response);
3446 length = strnlen(bcc_ptr, bytes_left - 2);
3447
Steve French50c2f752007-07-13 00:33:32 +00003448 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003449 if (length == 3) {
3450 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3451 (bcc_ptr[2] == 'C')) {
3452 cFYI(1, ("IPC connection"));
3453 tcon->ipc = 1;
3454 }
3455 } else if (length == 2) {
3456 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3457 /* the most common case */
3458 cFYI(1, ("disk share connection"));
3459 }
3460 }
Steve French50c2f752007-07-13 00:33:32 +00003461 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003462 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003464
3465 /* mostly informational -- no need to fail on error here */
Steve Frenchd185cda2009-04-30 17:45:10 +00003466 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3467 bytes_left,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003468 smb_buffer->Flags2 &
3469 SMBFLG2_UNICODE,
3470 nls_codepage);
3471
3472 cFYI(1, ("nativeFileSystem=%s", tcon->nativeFileSystem));
3473
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003474 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003475 (smb_buffer_response->WordCount == 7))
3476 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003477 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3478 else
3479 tcon->Flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3481 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003482 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483 ses->ipc_tid = smb_buffer_response->Tid;
3484 }
3485
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003486 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 return rc;
3488}
3489
3490int
3491cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3492{
3493 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00003494 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495
Jeff Laytonf1987b42008-11-15 11:12:47 -05003496 if (cifs_sb->tcon)
3497 cifs_put_tcon(cifs_sb->tcon);
Steve French50c2f752007-07-13 00:33:32 +00003498
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 cifs_sb->tcon = NULL;
Steve French2fe87f02006-09-21 07:02:52 +00003500 tmp = cifs_sb->prepath;
3501 cifs_sb->prepathlen = 0;
3502 cifs_sb->prepath = NULL;
3503 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504
Steve French88e7d702008-01-03 17:37:09 +00003505 return rc;
Steve French50c2f752007-07-13 00:33:32 +00003506}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507
3508int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
Steve French50c2f752007-07-13 00:33:32 +00003509 struct nls_table *nls_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003510{
3511 int rc = 0;
Steve French7c7b25b2006-06-01 19:20:10 +00003512 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
Steve French4b18f2a2008-04-29 00:06:05 +00003513 bool ntlmv2_flag = false;
Steve Frenchad009ac2005-04-28 22:41:05 -07003514 int first_time = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003515 struct TCP_Server_Info *server = pSesInfo->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516
3517 /* what if server changes its buffer size after dropping the session? */
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003518 if (server->maxBuf == 0) /* no need to send on reconnect */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519 rc = CIFSSMBNegotiate(xid, pSesInfo);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003520 if (rc == -EAGAIN) {
3521 /* retry only once on 1st time connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve French50c2f752007-07-13 00:33:32 +00003523 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524 rc = -EHOSTDOWN;
3525 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003526 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 spin_lock(&GlobalMid_Lock);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003528 if (server->tcpStatus != CifsExiting)
3529 server->tcpStatus = CifsGood;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 else
3531 rc = -EHOSTDOWN;
3532 spin_unlock(&GlobalMid_Lock);
3533
3534 }
Steve Frenchad009ac2005-04-28 22:41:05 -07003535 first_time = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536 }
Steve French26b994f2008-08-06 05:11:33 +00003537
3538 if (rc)
3539 goto ss_err_exit;
3540
3541 pSesInfo->flags = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003542 pSesInfo->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003543 if (linuxExtEnabled == 0)
3544 pSesInfo->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00003545
Steve French26b994f2008-08-06 05:11:33 +00003546 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003547 server->secMode, server->capabilities, server->timeAdj));
3548
Steve French20418ac2009-04-30 16:13:32 +00003549 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00003550 if (rc) {
3551 cERROR(1, ("Send error in SessSetup = %d", rc));
3552 } else {
3553 cFYI(1, ("CIFS Session Established successfully"));
Steve French20418ac2009-04-30 16:13:32 +00003554 spin_lock(&GlobalMid_Lock);
3555 pSesInfo->status = CifsGood;
3556 pSesInfo->need_reconnect = false;
3557 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003558 }
3559
Linus Torvalds1da177e2005-04-16 15:20:36 -07003560ss_err_exit:
3561 return rc;
3562}
3563