blob: e171067301689dee90ed97de96fc2fcb7eb3f518 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve French366781c2008-01-25 10:12:41 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
26#include <linux/ipv6.h>
27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070031#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070032#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000033#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070034#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
37#include <asm/processor.h>
38#include "cifspdu.h"
39#include "cifsglob.h"
40#include "cifsproto.h"
41#include "cifs_unicode.h"
42#include "cifs_debug.h"
43#include "cifs_fs_sb.h"
44#include "ntlmssp.h"
45#include "nterr.h"
46#include "rfc1002pdu.h"
Steve Frencha2653eb2005-11-10 15:33:38 -080047#include "cn_cifs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49#define CIFS_PORT 445
50#define RFC1001_PORT 139
51
Steve Frenchf1914012005-08-18 09:37:34 -070052static DECLARE_COMPLETION(cifsd_complete);
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 unsigned char *p24);
56
57extern mempool_t *cifs_req_poolp;
58
59struct smb_vol {
60 char *username;
61 char *password;
62 char *domainname;
63 char *UNC;
64 char *UNCip;
65 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[16]; /* netbios name of client */
Steve Frencha10faeb22005-08-22 21:38:31 -070068 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 uid_t linux_uid;
70 gid_t linux_gid;
71 mode_t file_mode;
72 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000073 unsigned secFlg;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 unsigned rw:1;
75 unsigned retry:1;
76 unsigned intr:1;
77 unsigned setuids:1;
Steve French4523cc32007-04-30 20:13:06 +000078 unsigned override_uid:1;
79 unsigned override_gid:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 unsigned noperm:1;
81 unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
Steve French0a4b92c2006-01-12 15:44:21 -080082 unsigned cifs_acl:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 unsigned no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 unsigned server_ino:1; /* use inode numbers from server ie UniqueId */
85 unsigned direct_io:1;
Steve French6a0b4822005-04-28 22:41:05 -070086 unsigned remap:1; /* set to remap seven reserved chars in filenames */
Jeremy Allisonac670552005-06-22 17:26:35 -070087 unsigned posix_paths:1; /* unset to not ask for posix pathnames. */
Steve Frenchc18c8422007-07-18 23:21:09 +000088 unsigned no_linux_ext:1;
Steve Frenchd7245c22005-07-14 18:25:12 -050089 unsigned sfu_emul:1;
Steve Frenchbf820672005-12-01 22:32:42 -080090 unsigned nullauth:1; /* attempt to authenticate with null user */
Steve Frenchc46fa8a2005-08-18 20:49:57 -070091 unsigned nocase; /* request case insensitive filenames */
92 unsigned nobrl; /* disable sending byte range locks to srv */
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 unsigned int rsize;
94 unsigned int wsize;
95 unsigned int sockopt;
96 unsigned short int port;
Steve Frenchfb8c4b12007-07-10 01:16:18 +000097 char *prepath;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098};
99
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000100static int ipv4_connect(struct sockaddr_in *psin_server,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 struct socket **csocket,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000102 char *netb_name,
103 char *server_netb_name);
104static int ipv6_connect(struct sockaddr_in6 *psin_server,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 struct socket **csocket);
106
107
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000108 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 * cifs tcp session reconnection
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000110 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 * mark tcp session as reconnecting so temporarily locked
112 * mark all smb sessions as reconnecting for tcp session
113 * reconnect tcp session
114 * wake up waiters on reconnection? - (not needed currently)
115 */
116
Steve French2cd646a2006-09-28 19:43:08 +0000117static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118cifs_reconnect(struct TCP_Server_Info *server)
119{
120 int rc = 0;
121 struct list_head *tmp;
122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000124 struct mid_q_entry *mid_entry;
Steve French50c2f752007-07-13 00:33:32 +0000125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 spin_lock(&GlobalMid_Lock);
Steve French26f57362007-08-30 22:09:15 +0000127 if (kthread_should_stop()) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000128 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
131 return rc;
132 } else
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
135 server->maxBuf = 0;
136
Steve Frenche4eb2952005-04-28 22:41:09 -0700137 cFYI(1, ("Reconnecting tcp session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
141 read_lock(&GlobalSMBSeslock);
142 list_for_each(tmp, &GlobalSMBSessionList) {
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
144 if (ses->server) {
145 if (ses->server == server) {
146 ses->status = CifsNeedReconnect;
147 ses->ipc_tid = 0;
148 }
149 }
150 /* else tcp and smb sessions need reconnection */
151 }
152 list_for_each(tmp, &GlobalTreeConnectionList) {
153 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
Steve French26f57362007-08-30 22:09:15 +0000154 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 tcon->tidStatus = CifsNeedReconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 }
157 read_unlock(&GlobalSMBSeslock);
158 /* do not want to be sending data on a socket we are freeing */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000159 down(&server->tcpSem);
160 if (server->ssocket) {
Steve French467a8f82007-06-27 22:41:32 +0000161 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 server->ssocket->flags));
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800163 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000164 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000165 server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 server->ssocket->flags));
167 sock_release(server->ssocket);
168 server->ssocket = NULL;
169 }
170
171 spin_lock(&GlobalMid_Lock);
172 list_for_each(tmp, &server->pending_mid_q) {
173 mid_entry = list_entry(tmp, struct
174 mid_q_entry,
175 qhead);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000176 if (mid_entry) {
177 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French09d1db52005-04-28 22:41:08 -0700178 /* Mark other intransit requests as needing
179 retry so we do not immediately mark the
180 session bad again (ie after we reconnect
181 below) as they timeout too */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 mid_entry->midState = MID_RETRY_NEEDED;
183 }
184 }
185 }
186 spin_unlock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000187 up(&server->tcpSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Steve French26f57362007-08-30 22:09:15 +0000189 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
Steve French6c3d8902006-07-31 22:46:20 +0000190 try_to_freeze();
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000191 if (server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,
193 &server->ssocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000195 rc = ipv4_connect(&server->addr.sockAddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 &server->ssocket,
Steve Frencha10faeb22005-08-22 21:38:31 -0700197 server->workstation_RFC1001_name,
198 server->server_RFC1001_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000200 if (rc) {
201 cFYI(1, ("reconnect error %d", rc));
Steve French0cb766a2005-04-28 22:41:11 -0700202 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 } else {
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
Steve French26f57362007-08-30 22:09:15 +0000206 if (!kthread_should_stop())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 server->tcpStatus = CifsGood;
Steve Frenchad009ac2005-04-28 22:41:05 -0700208 server->sequence_number = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000209 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 /* atomic_set(&server->inFlight,0);*/
211 wake_up(&server->response_q);
212 }
213 }
214 return rc;
215}
216
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000217/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700218 return codes:
219 0 not a transact2, or all data present
220 >0 transact2 with that much data missing
221 -EINVAL = invalid transact2
222
223 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000224static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700225{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000226 struct smb_t2_rsp *pSMBt;
227 int total_data_size;
Steve Frenche4eb2952005-04-28 22:41:09 -0700228 int data_in_this_rsp;
229 int remaining;
230
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000231 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700232 return 0;
233
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000234 /* check for plausible wct, bcc and t2 data and parm sizes */
235 /* check for parm and data offset going beyond end of smb */
236 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Steve French467a8f82007-06-27 22:41:32 +0000237 cFYI(1, ("invalid transact2 word count"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700238 return -EINVAL;
239 }
240
241 pSMBt = (struct smb_t2_rsp *)pSMB;
242
243 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
244 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
245
246 remaining = total_data_size - data_in_this_rsp;
247
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000248 if (remaining == 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700249 return 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000250 else if (remaining < 0) {
Steve French467a8f82007-06-27 22:41:32 +0000251 cFYI(1, ("total data %d smaller than data in frame %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700252 total_data_size, data_in_this_rsp));
253 return -EINVAL;
254 } else {
Steve French467a8f82007-06-27 22:41:32 +0000255 cFYI(1, ("missing %d bytes from transact2, check next response",
Steve Frenche4eb2952005-04-28 22:41:09 -0700256 remaining));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000257 if (total_data_size > maxBufSize) {
258 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
259 total_data_size, maxBufSize));
260 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700261 }
262 return remaining;
263 }
264}
265
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000266static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700267{
268 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
269 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
270 int total_data_size;
271 int total_in_buf;
272 int remaining;
273 int total_in_buf2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000274 char *data_area_of_target;
275 char *data_area_of_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700276 __u16 byte_count;
277
278 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
279
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000280 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
Steve French63135e02007-07-17 17:34:02 +0000281 cFYI(1, ("total data size of primary and secondary t2 differ"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700282 }
283
284 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
285
286 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000287
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000288 if (remaining < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700289 return -EINVAL;
290
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000291 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700292 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000293
Steve Frenche4eb2952005-04-28 22:41:09 -0700294 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000295 if (remaining < total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000296 cFYI(1, ("transact2 2nd response contains too much data"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700297 }
298
299 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000300 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Steve Frenche4eb2952005-04-28 22:41:09 -0700301 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
302 /* validate target area */
303
304 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000305 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700306
307 data_area_of_target += total_in_buf;
308
309 /* copy second buffer into end of first buffer */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000310 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
Steve Frenche4eb2952005-04-28 22:41:09 -0700311 total_in_buf += total_in_buf2;
312 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
313 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
314 byte_count += total_in_buf2;
315 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
316
Steve French70ca7342005-09-22 16:32:06 -0700317 byte_count = pTargetSMB->smb_buf_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700318 byte_count += total_in_buf2;
319
320 /* BB also add check that we are not beyond maximum buffer size */
Steve French50c2f752007-07-13 00:33:32 +0000321
Steve French70ca7342005-09-22 16:32:06 -0700322 pTargetSMB->smb_buf_length = byte_count;
Steve Frenche4eb2952005-04-28 22:41:09 -0700323
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000324 if (remaining == total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000325 cFYI(1, ("found the last secondary response"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700326 return 0; /* we are done */
327 } else /* more responses to go */
328 return 1;
329
330}
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332static int
333cifs_demultiplex_thread(struct TCP_Server_Info *server)
334{
335 int length;
336 unsigned int pdu_length, total_read;
337 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700338 struct smb_hdr *bigbuf = NULL;
339 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 struct msghdr smb_msg;
341 struct kvec iov;
342 struct socket *csocket = server->ssocket;
343 struct list_head *tmp;
344 struct cifsSesInfo *ses;
345 struct task_struct *task_to_wake = NULL;
346 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700347 char temp;
Steve Frenchb8643e12005-04-28 22:41:07 -0700348 int isLargeBuf = FALSE;
Steve Frenche4eb2952005-04-28 22:41:09 -0700349 int isMultiRsp;
350 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 current->flags |= PF_MEMALLOC;
353 server->tsk = current; /* save process info to wake at shutdown */
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700354 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000355 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 atomic_inc(&tcpSesAllocCount);
357 length = tcpSesAllocCount.counter;
358 write_unlock(&GlobalSMBSeslock);
Steve Frenchf1914012005-08-18 09:37:34 -0700359 complete(&cifsd_complete);
Steve French26f57362007-08-30 22:09:15 +0000360 if (length > 1)
361 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
362 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700364 set_freezable();
Igor Mammedovaaf737a2007-04-03 19:16:43 +0000365 while (!kthread_should_stop()) {
Steve Frenchede13272005-08-30 20:10:14 -0700366 if (try_to_freeze())
367 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700368 if (bigbuf == NULL) {
369 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000370 if (!bigbuf) {
371 cERROR(1, ("No memory for large SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700372 msleep(3000);
373 /* retry will check if exiting */
374 continue;
375 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000376 } else if (isLargeBuf) {
377 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000378 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700380
381 if (smallbuf == NULL) {
382 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000383 if (!smallbuf) {
384 cERROR(1, ("No memory for SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700385 msleep(1000);
386 /* retry will check if exiting */
387 continue;
388 }
389 /* beginning of smb buffer is cleared in our buf_get */
390 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000391 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700392
393 isLargeBuf = FALSE;
Steve Frenche4eb2952005-04-28 22:41:09 -0700394 isMultiRsp = FALSE;
Steve Frenchb8643e12005-04-28 22:41:07 -0700395 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 iov.iov_base = smb_buffer;
397 iov.iov_len = 4;
398 smb_msg.msg_control = NULL;
399 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000400 pdu_length = 4; /* enough to get RFC1001 header */
401incomplete_rcv:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 length =
403 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000404 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Steve French26f57362007-08-30 22:09:15 +0000406 if (kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 break;
408 } else if (server->tcpStatus == CifsNeedReconnect) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000409 cFYI(1, ("Reconnect after server stopped responding"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 cifs_reconnect(server);
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000411 cFYI(1, ("call to reconnect done"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 csocket = server->ssocket;
413 continue;
414 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700415 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 allowing socket to clear and app threads to set
417 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc18c7322007-10-17 18:01:11 +0000418 if (pdu_length < 4)
419 goto incomplete_rcv;
420 else
421 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 } else if (length <= 0) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000423 if (server->tcpStatus == CifsNew) {
424 cFYI(1, ("tcp session abend after SMBnegprot"));
Steve French09d1db52005-04-28 22:41:08 -0700425 /* some servers kill the TCP session rather than
426 returning an SMB negprot error, in which
427 case reconnecting here is not going to help,
428 and so simply return error to mount */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 break;
430 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000431 if (!try_to_freeze() && (length == -EINTR)) {
Steve French467a8f82007-06-27 22:41:32 +0000432 cFYI(1, ("cifsd thread killed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 break;
434 }
Steve French467a8f82007-06-27 22:41:32 +0000435 cFYI(1, ("Reconnect after unexpected peek error %d",
Steve French57337e42005-04-28 22:41:10 -0700436 length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 cifs_reconnect(server);
438 csocket = server->ssocket;
439 wake_up(&server->response_q);
440 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000441 } else if (length < pdu_length) {
442 cFYI(1, ("requested %d bytes but only got %d bytes",
443 pdu_length, length));
Steve Frenchf01d5e12007-08-30 21:13:31 +0000444 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000445 msleep(1);
446 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 }
Steve French67010fb2005-04-28 22:41:09 -0700448
Steve French70ca7342005-09-22 16:32:06 -0700449 /* The right amount was read from socket - 4 bytes */
450 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700451
Steve French70ca7342005-09-22 16:32:06 -0700452 /* the first byte big endian of the length field,
453 is actually not part of the length but the type
454 with the most common, zero, as regular data */
455 temp = *((char *) smb_buffer);
456
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000457 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700458 but we convert it here so it is always manipulated
459 as host byte order */
Steve French46810cb2005-04-28 22:41:09 -0700460 pdu_length = ntohl(smb_buffer->smb_buf_length);
Steve French70ca7342005-09-22 16:32:06 -0700461 smb_buffer->smb_buf_length = pdu_length;
Steve French46810cb2005-04-28 22:41:09 -0700462
Steve French467a8f82007-06-27 22:41:32 +0000463 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
Steve French70ca7342005-09-22 16:32:06 -0700464
465 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000466 continue;
Steve French70ca7342005-09-22 16:32:06 -0700467 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Steve French467a8f82007-06-27 22:41:32 +0000468 cFYI(1, ("Good RFC 1002 session rsp"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700469 continue;
Steve French70ca7342005-09-22 16:32:06 -0700470 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000471 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700472 an error on SMB negprot response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000473 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
Steve French70ca7342005-09-22 16:32:06 -0700474 pdu_length));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000475 if (server->tcpStatus == CifsNew) {
476 /* if nack on negprot (rather than
Steve French46810cb2005-04-28 22:41:09 -0700477 ret of smb negprot error) reconnecting
478 not going to help, ret error to mount */
479 break;
480 } else {
481 /* give server a second to
482 clean up before reconnect attempt */
483 msleep(1000);
484 /* always try 445 first on reconnect
485 since we get NACK on some if we ever
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000486 connected to port 139 (the NACK is
Steve French46810cb2005-04-28 22:41:09 -0700487 since we do not begin with RFC1001
488 session initialize frame) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000489 server->addr.sockAddr.sin_port =
Steve French46810cb2005-04-28 22:41:09 -0700490 htons(CIFS_PORT);
491 cifs_reconnect(server);
492 csocket = server->ssocket;
493 wake_up(&server->response_q);
494 continue;
495 }
Steve French70ca7342005-09-22 16:32:06 -0700496 } else if (temp != (char) 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000497 cERROR(1, ("Unknown RFC 1002 frame"));
Steve French70ca7342005-09-22 16:32:06 -0700498 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
499 length);
Steve French46810cb2005-04-28 22:41:09 -0700500 cifs_reconnect(server);
501 csocket = server->ssocket;
502 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700503 }
504
505 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000506 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000507 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700508 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
Steve French46810cb2005-04-28 22:41:09 -0700509 length, pdu_length+4));
Steve Frenche4eb2952005-04-28 22:41:09 -0700510 cifs_reconnect(server);
511 csocket = server->ssocket;
512 wake_up(&server->response_q);
513 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000514 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700515
516 /* else length ok */
517 reconnect = 0;
518
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000519 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700520 isLargeBuf = TRUE;
521 memcpy(bigbuf, smallbuf, 4);
522 smb_buffer = bigbuf;
523 }
524 length = 0;
525 iov.iov_base = 4 + (char *)smb_buffer;
526 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000527 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700528 total_read += length) {
529 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
530 pdu_length - total_read, 0);
Steve French26f57362007-08-30 22:09:15 +0000531 if (kthread_should_stop() ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700532 (length == -EINTR)) {
533 /* then will exit */
534 reconnect = 2;
535 break;
536 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700537 cifs_reconnect(server);
538 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000539 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700540 /* Now we will reread sock */
541 reconnect = 1;
542 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000543 } else if ((length == -ERESTARTSYS) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700544 (length == -EAGAIN)) {
545 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000546 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700547 threads to set tcpStatus
548 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000549 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700550 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700551 } else if (length <= 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000552 cERROR(1, ("Received no data, expecting %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700553 pdu_length - total_read));
554 cifs_reconnect(server);
555 csocket = server->ssocket;
556 reconnect = 1;
557 break;
Steve French46810cb2005-04-28 22:41:09 -0700558 }
559 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000560 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700561 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000562 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700563 continue;
564
565 length += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000566
Steve Frenche4eb2952005-04-28 22:41:09 -0700567
568 dump_smb(smb_buffer, length);
Steve French184ed212006-02-24 06:15:11 +0000569 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
Steve Frenchb387eae2005-10-10 14:21:15 -0700570 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
Steve Frenche4eb2952005-04-28 22:41:09 -0700571 continue;
572 }
573
574
575 task_to_wake = NULL;
576 spin_lock(&GlobalMid_Lock);
577 list_for_each(tmp, &server->pending_mid_q) {
578 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
579
Steve French50c2f752007-07-13 00:33:32 +0000580 if ((mid_entry->mid == smb_buffer->Mid) &&
Steve Frenche4eb2952005-04-28 22:41:09 -0700581 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
582 (mid_entry->command == smb_buffer->Command)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000583 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700584 /* We have a multipart transact2 resp */
Steve Frenchcd634992005-04-28 22:41:10 -0700585 isMultiRsp = TRUE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000586 if (mid_entry->resp_buf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700587 /* merge response - fix up 1st*/
Steve French50c2f752007-07-13 00:33:32 +0000588 if (coalesce_t2(smb_buffer,
Steve Frenche4eb2952005-04-28 22:41:09 -0700589 mid_entry->resp_buf)) {
Steve French39798772006-05-31 22:40:51 +0000590 mid_entry->multiRsp = 1;
Steve Frenche4eb2952005-04-28 22:41:09 -0700591 break;
592 } else {
593 /* all parts received */
Steve French39798772006-05-31 22:40:51 +0000594 mid_entry->multiEnd = 1;
Steve French50c2f752007-07-13 00:33:32 +0000595 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700596 }
597 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000598 if (!isLargeBuf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700599 cERROR(1,("1st trans2 resp needs bigbuf"));
600 /* BB maybe we can fix this up, switch
Steve French50c2f752007-07-13 00:33:32 +0000601 to already allocated large buffer? */
Steve Frenche4eb2952005-04-28 22:41:09 -0700602 } else {
Steve Frenchcd634992005-04-28 22:41:10 -0700603 /* Have first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700604 mid_entry->resp_buf =
605 smb_buffer;
606 mid_entry->largeBuf = 1;
Steve Frenche4eb2952005-04-28 22:41:09 -0700607 bigbuf = NULL;
608 }
609 }
610 break;
Steve French50c2f752007-07-13 00:33:32 +0000611 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700612 mid_entry->resp_buf = smb_buffer;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000613 if (isLargeBuf)
Steve Frenche4eb2952005-04-28 22:41:09 -0700614 mid_entry->largeBuf = 1;
615 else
616 mid_entry->largeBuf = 0;
617multi_t2_fnd:
618 task_to_wake = mid_entry->tsk;
619 mid_entry->midState = MID_RESPONSE_RECEIVED;
Steve French1047abc2005-10-11 19:58:06 -0700620#ifdef CONFIG_CIFS_STATS2
621 mid_entry->when_received = jiffies;
622#endif
Steve French3a5ff612006-07-14 22:37:11 +0000623 /* so we do not time out requests to server
624 which is still responding (since server could
625 be busy but not dead) */
626 server->lstrp = jiffies;
Steve Frenche4eb2952005-04-28 22:41:09 -0700627 break;
628 }
629 }
630 spin_unlock(&GlobalMid_Lock);
631 if (task_to_wake) {
Steve Frenchcd634992005-04-28 22:41:10 -0700632 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000633 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700634 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000635 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700636 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000637 else
Steve Frenchcd634992005-04-28 22:41:10 -0700638 smallbuf = NULL;
639 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700640 wake_up_process(task_to_wake);
Steve Frenchd7c8c942006-03-03 10:43:49 +0000641 } else if ((is_valid_oplock_break(smb_buffer, server) == FALSE)
Steve French50c2f752007-07-13 00:33:32 +0000642 && (isMultiRsp == FALSE)) {
643 cERROR(1, ("No task to wake, unknown frame received! "
644 "NumMids %d", midCount.counter));
645 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700646 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000647#ifdef CONFIG_CIFS_DEBUG2
648 cifs_dump_detail(smb_buffer);
649 cifs_dump_mids(server);
650#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000651
Steve Frenche4eb2952005-04-28 22:41:09 -0700652 }
653 } /* end while !EXITING */
654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 spin_lock(&GlobalMid_Lock);
656 server->tcpStatus = CifsExiting;
657 server->tsk = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700658 /* check if we have blocked requests that need to free */
659 /* Note that cifs_max_pending is normally 50, but
660 can be set at module install time to as little as two */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000661 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700662 atomic_set(&server->inFlight, cifs_max_pending - 1);
663 /* We do not want to set the max_pending too low or we
664 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000666 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700668 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 to the same server - they now will see the session is in exit state
670 and get out of SendReceive. */
671 wake_up_all(&server->request_q);
672 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700673 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000674
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000675 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 sock_release(csocket);
677 server->ssocket = NULL;
678 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700679 /* buffer usuallly freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000680 cifs_buf_release(bigbuf);
681 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700682 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
684 read_lock(&GlobalSMBSeslock);
685 if (list_empty(&server->pending_mid_q)) {
Steve French09d1db52005-04-28 22:41:08 -0700686 /* loop through server session structures attached to this and
687 mark them dead */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 list_for_each(tmp, &GlobalSMBSessionList) {
689 ses =
690 list_entry(tmp, struct cifsSesInfo,
691 cifsSessionList);
692 if (ses->server == server) {
693 ses->status = CifsExiting;
694 ses->server = NULL;
695 }
696 }
697 read_unlock(&GlobalSMBSeslock);
698 } else {
Steve French31ca3bc2005-04-28 22:41:11 -0700699 /* although we can not zero the server struct pointer yet,
700 since there are active requests which may depnd on them,
701 mark the corresponding SMB sessions as exiting too */
702 list_for_each(tmp, &GlobalSMBSessionList) {
703 ses = list_entry(tmp, struct cifsSesInfo,
704 cifsSessionList);
Steve French26f57362007-08-30 22:09:15 +0000705 if (ses->server == server)
Steve French31ca3bc2005-04-28 22:41:11 -0700706 ses->status = CifsExiting;
Steve French31ca3bc2005-04-28 22:41:11 -0700707 }
708
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 spin_lock(&GlobalMid_Lock);
710 list_for_each(tmp, &server->pending_mid_q) {
711 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
712 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French50c2f752007-07-13 00:33:32 +0000713 cFYI(1, ("Clearing Mid 0x%x - waking up ",
714 mid_entry->mid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 task_to_wake = mid_entry->tsk;
Steve French26f57362007-08-30 22:09:15 +0000716 if (task_to_wake)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 wake_up_process(task_to_wake);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 }
719 }
720 spin_unlock(&GlobalMid_Lock);
721 read_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700723 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 }
725
Steve Frenchf1914012005-08-18 09:37:34 -0700726 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000727 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700729 /* due to delays on oplock break requests, we need
730 to wait at least 45 seconds before giving up
731 on a request getting a response and going ahead
732 and killing cifsd */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 cFYI(1, ("Wait for exit from demultiplex thread"));
Steve French31ca3bc2005-04-28 22:41:11 -0700734 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 /* if threads still have not exited they are probably never
736 coming home not much else we can do but free the memory */
737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
739 write_lock(&GlobalSMBSeslock);
740 atomic_dec(&tcpSesAllocCount);
741 length = tcpSesAllocCount.counter;
Steve French31ca3bc2005-04-28 22:41:11 -0700742
743 /* last chance to mark ses pointers invalid
744 if there are any pointing to this (e.g
Steve French50c2f752007-07-13 00:33:32 +0000745 if a crazy root user tried to kill cifsd
Steve French31ca3bc2005-04-28 22:41:11 -0700746 kernel thread explicitly this might happen) */
747 list_for_each(tmp, &GlobalSMBSessionList) {
748 ses = list_entry(tmp, struct cifsSesInfo,
749 cifsSessionList);
Steve French26f57362007-08-30 22:09:15 +0000750 if (ses->server == server)
Steve French31ca3bc2005-04-28 22:41:11 -0700751 ses->server = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700752 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 write_unlock(&GlobalSMBSeslock);
Steve French31ca3bc2005-04-28 22:41:11 -0700754
Jeff Laytonc359cf32007-11-16 22:22:06 +0000755 kfree(server->hostname);
Steve French31ca3bc2005-04-28 22:41:11 -0700756 kfree(server);
Steve French26f57362007-08-30 22:09:15 +0000757 if (length > 0)
758 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
759 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000760
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 return 0;
762}
763
Jeff Laytonc359cf32007-11-16 22:22:06 +0000764/* extract the host portion of the UNC string */
765static char *
766extract_hostname(const char *unc)
767{
768 const char *src;
769 char *dst, *delim;
770 unsigned int len;
771
772 /* skip double chars at beginning of string */
773 /* BB: check validity of these bytes? */
774 src = unc + 2;
775
776 /* delimiter between hostname and sharename is always '\\' now */
777 delim = strchr(src, '\\');
778 if (!delim)
779 return ERR_PTR(-EINVAL);
780
781 len = delim - src;
782 dst = kmalloc((len + 1), GFP_KERNEL);
783 if (dst == NULL)
784 return ERR_PTR(-ENOMEM);
785
786 memcpy(dst, src, len);
787 dst[len] = '\0';
788
789 return dst;
790}
791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792static int
Steve French50c2f752007-07-13 00:33:32 +0000793cifs_parse_mount_options(char *options, const char *devname,
794 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
796 char *value;
797 char *data;
798 unsigned int temp_len, i, j;
799 char separator[2];
800
801 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000802 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Linus Torvalds12e36b22006-10-13 08:09:29 -0700804 if (Local_System_Name[0] != 0)
Steve French50c2f752007-07-13 00:33:32 +0000805 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
Steve French2cd646a2006-09-28 19:43:08 +0000806 else {
Linus Torvalds12e36b22006-10-13 08:09:29 -0700807 char *nodename = utsname()->nodename;
Steve French50c2f752007-07-13 00:33:32 +0000808 int n = strnlen(nodename, 15);
809 memset(vol->source_rfc1001_name, 0x20, 15);
810 for (i = 0; i < n; i++) {
Steve French2cd646a2006-09-28 19:43:08 +0000811 /* does not have to be perfect mapping since field is
812 informational, only used for servers that do not support
813 port 445 and it can be overridden at mount time */
Linus Torvalds12e36b22006-10-13 08:09:29 -0700814 vol->source_rfc1001_name[i] = toupper(nodename[i]);
Steve French2cd646a2006-09-28 19:43:08 +0000815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 }
817 vol->source_rfc1001_name[15] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700818 /* null target name indicates to use *SMBSERVR default called name
819 if we end up sending RFC1001 session initialize */
820 vol->target_rfc1001_name[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 vol->linux_uid = current->uid; /* current->euid instead? */
822 vol->linux_gid = current->gid;
823 vol->dir_mode = S_IRWXUGO;
824 /* 2767 perms indicate mandatory locking support */
Steve French7505e052007-11-01 18:03:01 +0000825 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
827 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
828 vol->rw = TRUE;
Jeremy Allisonac670552005-06-22 17:26:35 -0700829 /* default is always to request posix paths. */
830 vol->posix_paths = 1;
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 if (!options)
833 return 1;
834
Steve French50c2f752007-07-13 00:33:32 +0000835 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000836 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 separator[0] = options[4];
838 options += 5;
839 } else {
Steve French467a8f82007-06-27 22:41:32 +0000840 cFYI(1, ("Null separator not allowed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 }
842 }
Steve French50c2f752007-07-13 00:33:32 +0000843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 while ((data = strsep(&options, separator)) != NULL) {
845 if (!*data)
846 continue;
847 if ((value = strchr(data, '=')) != NULL)
848 *value++ = '\0';
849
Steve French50c2f752007-07-13 00:33:32 +0000850 /* Have to parse this before we parse for "user" */
851 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000853 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 vol->no_xattr = 1;
855 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000856 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 printk(KERN_WARNING
858 "CIFS: invalid or missing username\n");
859 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000860 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000861 /* null user, ie anonymous, authentication */
862 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
864 if (strnlen(value, 200) < 200) {
865 vol->username = value;
866 } else {
867 printk(KERN_WARNING "CIFS: username too long\n");
868 return 1;
869 }
870 } else if (strnicmp(data, "pass", 4) == 0) {
871 if (!value) {
872 vol->password = NULL;
873 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000874 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 /* check if string begins with double comma
876 since that would mean the password really
877 does start with a comma, and would not
878 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000879 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 vol->password = NULL;
881 continue;
882 }
883 }
884 temp_len = strlen(value);
885 /* removed password length check, NTLM passwords
886 can be arbitrarily long */
887
Steve French50c2f752007-07-13 00:33:32 +0000888 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 prematurely null terminated. Commas in password are
890 specified across the cifs mount interface by a double
891 comma ie ,, and a comma used as in other cases ie ','
892 as a parameter delimiter/separator is single and due
893 to the strsep above is temporarily zeroed. */
894
895 /* NB: password legally can have multiple commas and
896 the only illegal character in a password is null */
897
Steve French50c2f752007-07-13 00:33:32 +0000898 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700899 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 /* reinsert comma */
901 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000902 temp_len += 2; /* move after second comma */
903 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000905 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700906 separator[0]) {
907 /* skip second comma */
908 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000909 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 /* single comma indicating start
911 of next parm */
912 break;
913 }
914 }
915 temp_len++;
916 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000917 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 options = NULL;
919 } else {
920 value[temp_len] = 0;
921 /* point option to start of next parm */
922 options = value + temp_len + 1;
923 }
Steve French50c2f752007-07-13 00:33:32 +0000924 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 double commas to singles. Note that this ends up
926 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700927 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000928 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000929 printk(KERN_WARNING "CIFS: no memory "
930 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700931 return 1;
932 }
Steve French50c2f752007-07-13 00:33:32 +0000933 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000935 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700936 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 /* skip second comma */
938 i++;
939 }
940 }
941 vol->password[j] = 0;
942 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700943 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000944 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000945 printk(KERN_WARNING "CIFS: no memory "
946 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700947 return 1;
948 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 strcpy(vol->password, value);
950 }
951 } else if (strnicmp(data, "ip", 2) == 0) {
952 if (!value || !*value) {
953 vol->UNCip = NULL;
954 } else if (strnlen(value, 35) < 35) {
955 vol->UNCip = value;
956 } else {
Steve French50c2f752007-07-13 00:33:32 +0000957 printk(KERN_WARNING "CIFS: ip address "
958 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 return 1;
960 }
Steve French50c2f752007-07-13 00:33:32 +0000961 } else if (strnicmp(data, "sec", 3) == 0) {
962 if (!value || !*value) {
963 cERROR(1, ("no security value specified"));
964 continue;
965 } else if (strnicmp(value, "krb5i", 5) == 0) {
966 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000967 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800968 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000969 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
970 CIFSSEC_MAY_KRB5; */
971 cERROR(1, ("Krb5 cifs privacy not supported"));
Steve Frenchbf820672005-12-01 22:32:42 -0800972 return 1;
973 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000974 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchbf820672005-12-01 22:32:42 -0800975 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000976 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000977 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800978 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000979 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -0800980 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000981 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +0000982 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800983 } else if (strnicmp(value, "ntlm", 4) == 0) {
984 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +0000985 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -0800986 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +0000987 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +0000988 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +0000989#ifdef CONFIG_CIFS_WEAK_PW_HASH
990 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000991 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +0000992#endif
Steve Frenchbf820672005-12-01 22:32:42 -0800993 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +0000994 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +0000995 } else {
996 cERROR(1, ("bad security option: %s", value));
997 return 1;
998 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 } else if ((strnicmp(data, "unc", 3) == 0)
1000 || (strnicmp(data, "target", 6) == 0)
1001 || (strnicmp(data, "path", 4) == 0)) {
1002 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001003 printk(KERN_WARNING "CIFS: invalid path to "
1004 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 return 1; /* needs_arg; */
1006 }
1007 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001008 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001009 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001011 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 if (strncmp(vol->UNC, "//", 2) == 0) {
1013 vol->UNC[0] = '\\';
1014 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001015 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001017 "CIFS: UNC Path does not begin "
1018 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 return 1;
1020 }
1021 } else {
1022 printk(KERN_WARNING "CIFS: UNC name too long\n");
1023 return 1;
1024 }
1025 } else if ((strnicmp(data, "domain", 3) == 0)
1026 || (strnicmp(data, "workgroup", 5) == 0)) {
1027 if (!value || !*value) {
1028 printk(KERN_WARNING "CIFS: invalid domain name\n");
1029 return 1; /* needs_arg; */
1030 }
1031 /* BB are there cases in which a comma can be valid in
1032 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001033 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 vol->domainname = value;
1035 cFYI(1, ("Domain name set"));
1036 } else {
Steve French50c2f752007-07-13 00:33:32 +00001037 printk(KERN_WARNING "CIFS: domain name too "
1038 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 return 1;
1040 }
Steve French50c2f752007-07-13 00:33:32 +00001041 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1042 if (!value || !*value) {
1043 printk(KERN_WARNING
1044 "CIFS: invalid path prefix\n");
1045 return 1; /* needs_argument */
1046 }
1047 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001048 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001049 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001050 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1051 if (vol->prepath == NULL)
1052 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001053 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001054 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001055 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001056 } else
Steve French50c2f752007-07-13 00:33:32 +00001057 strcpy(vol->prepath, value);
1058 cFYI(1, ("prefix path %s", vol->prepath));
1059 } else {
1060 printk(KERN_WARNING "CIFS: prefix too long\n");
1061 return 1;
1062 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 } else if (strnicmp(data, "iocharset", 9) == 0) {
1064 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001065 printk(KERN_WARNING "CIFS: invalid iocharset "
1066 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return 1; /* needs_arg; */
1068 }
1069 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001070 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001072 /* if iocharset not set then load_nls_default
1073 is used by caller */
1074 cFYI(1, ("iocharset set to %s", value));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 } else {
Steve French63135e02007-07-17 17:34:02 +00001076 printk(KERN_WARNING "CIFS: iocharset name "
1077 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 return 1;
1079 }
1080 } else if (strnicmp(data, "uid", 3) == 0) {
1081 if (value && *value) {
1082 vol->linux_uid =
1083 simple_strtoul(value, &value, 0);
Steve French4523cc32007-04-30 20:13:06 +00001084 vol->override_uid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 }
1086 } else if (strnicmp(data, "gid", 3) == 0) {
1087 if (value && *value) {
1088 vol->linux_gid =
1089 simple_strtoul(value, &value, 0);
Steve French4523cc32007-04-30 20:13:06 +00001090 vol->override_gid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 }
1092 } else if (strnicmp(data, "file_mode", 4) == 0) {
1093 if (value && *value) {
1094 vol->file_mode =
1095 simple_strtoul(value, &value, 0);
1096 }
1097 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1098 if (value && *value) {
1099 vol->dir_mode =
1100 simple_strtoul(value, &value, 0);
1101 }
1102 } else if (strnicmp(data, "dirmode", 4) == 0) {
1103 if (value && *value) {
1104 vol->dir_mode =
1105 simple_strtoul(value, &value, 0);
1106 }
1107 } else if (strnicmp(data, "port", 4) == 0) {
1108 if (value && *value) {
1109 vol->port =
1110 simple_strtoul(value, &value, 0);
1111 }
1112 } else if (strnicmp(data, "rsize", 5) == 0) {
1113 if (value && *value) {
1114 vol->rsize =
1115 simple_strtoul(value, &value, 0);
1116 }
1117 } else if (strnicmp(data, "wsize", 5) == 0) {
1118 if (value && *value) {
1119 vol->wsize =
1120 simple_strtoul(value, &value, 0);
1121 }
1122 } else if (strnicmp(data, "sockopt", 5) == 0) {
1123 if (value && *value) {
1124 vol->sockopt =
1125 simple_strtoul(value, &value, 0);
1126 }
1127 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1128 if (!value || !*value || (*value == ' ')) {
Steve French63135e02007-07-17 17:34:02 +00001129 cFYI(1, ("invalid (empty) netbiosname"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 } else {
Steve French50c2f752007-07-13 00:33:32 +00001131 memset(vol->source_rfc1001_name, 0x20, 15);
1132 for (i = 0; i < 15; i++) {
1133 /* BB are there cases in which a comma can be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 valid in this workstation netbios name (and need
1135 special handling)? */
1136
1137 /* We do not uppercase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001138 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 break;
Steve French50c2f752007-07-13 00:33:32 +00001140 else
1141 vol->source_rfc1001_name[i] =
1142 value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 }
1144 /* The string has 16th byte zero still from
1145 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001146 if ((i == 15) && (value[i] != 0))
1147 printk(KERN_WARNING "CIFS: netbiosname"
1148 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001149 }
1150 } else if (strnicmp(data, "servern", 7) == 0) {
1151 /* servernetbiosname specified override *SMBSERVER */
1152 if (!value || !*value || (*value == ' ')) {
Steve French467a8f82007-06-27 22:41:32 +00001153 cFYI(1, ("empty server netbiosname specified"));
Steve Frencha10faeb22005-08-22 21:38:31 -07001154 } else {
1155 /* last byte, type, is 0x20 for servr type */
Steve French50c2f752007-07-13 00:33:32 +00001156 memset(vol->target_rfc1001_name, 0x20, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001157
Steve French50c2f752007-07-13 00:33:32 +00001158 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001159 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001160 valid in this workstation netbios name
1161 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001162
Steve French50c2f752007-07-13 00:33:32 +00001163 /* user or mount helper must uppercase
1164 the netbiosname */
1165 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001166 break;
1167 else
Steve French50c2f752007-07-13 00:33:32 +00001168 vol->target_rfc1001_name[i] =
1169 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001170 }
1171 /* The string has 16th byte zero still from
1172 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001173 if ((i == 15) && (value[i] != 0))
1174 printk(KERN_WARNING "CIFS: server net"
1175 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 }
1177 } else if (strnicmp(data, "credentials", 4) == 0) {
1178 /* ignore */
1179 } else if (strnicmp(data, "version", 3) == 0) {
1180 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001181 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 /* ignore */
1183 } else if (strnicmp(data, "rw", 2) == 0) {
1184 vol->rw = TRUE;
1185 } else if ((strnicmp(data, "suid", 4) == 0) ||
1186 (strnicmp(data, "nosuid", 6) == 0) ||
1187 (strnicmp(data, "exec", 4) == 0) ||
1188 (strnicmp(data, "noexec", 6) == 0) ||
1189 (strnicmp(data, "nodev", 5) == 0) ||
1190 (strnicmp(data, "noauto", 6) == 0) ||
1191 (strnicmp(data, "dev", 3) == 0)) {
1192 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001193 uses these opts to set flags, and the flags are read
1194 by the kernel vfs layer before we get here (ie
1195 before read super) so there is no point trying to
1196 parse these options again and set anything and it
1197 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 continue;
1199 } else if (strnicmp(data, "ro", 2) == 0) {
1200 vol->rw = FALSE;
1201 } else if (strnicmp(data, "hard", 4) == 0) {
1202 vol->retry = 1;
1203 } else if (strnicmp(data, "soft", 4) == 0) {
1204 vol->retry = 0;
1205 } else if (strnicmp(data, "perm", 4) == 0) {
1206 vol->noperm = 0;
1207 } else if (strnicmp(data, "noperm", 6) == 0) {
1208 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001209 } else if (strnicmp(data, "mapchars", 8) == 0) {
1210 vol->remap = 1;
1211 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1212 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001213 } else if (strnicmp(data, "sfu", 3) == 0) {
1214 vol->sfu_emul = 1;
1215 } else if (strnicmp(data, "nosfu", 5) == 0) {
1216 vol->sfu_emul = 0;
Jeremy Allisonac670552005-06-22 17:26:35 -07001217 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1218 vol->posix_paths = 1;
1219 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1220 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001221 } else if (strnicmp(data, "nounix", 6) == 0) {
1222 vol->no_linux_ext = 1;
1223 } else if (strnicmp(data, "nolinux", 7) == 0) {
1224 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001225 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001226 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001227 vol->nocase = 1;
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001228 } else if (strnicmp(data, "brl", 3) == 0) {
1229 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001230 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001231 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001232 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001233 /* turn off mandatory locking in mode
1234 if remote locking is turned off since the
1235 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001236 if (vol->file_mode ==
1237 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001238 vol->file_mode = S_IALLUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 } else if (strnicmp(data, "setuids", 7) == 0) {
1240 vol->setuids = 1;
1241 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1242 vol->setuids = 0;
1243 } else if (strnicmp(data, "nohard", 6) == 0) {
1244 vol->retry = 0;
1245 } else if (strnicmp(data, "nosoft", 6) == 0) {
1246 vol->retry = 1;
1247 } else if (strnicmp(data, "nointr", 6) == 0) {
1248 vol->intr = 0;
1249 } else if (strnicmp(data, "intr", 4) == 0) {
1250 vol->intr = 1;
Steve French50c2f752007-07-13 00:33:32 +00001251 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001253 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001255 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001256 vol->cifs_acl = 1;
1257 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1258 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001259 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001261 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 vol->no_psx_acl = 1;
Steve French50c2f752007-07-13 00:33:32 +00001263 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001264 vol->secFlg |= CIFSSEC_MUST_SIGN;
1265/* } else if (strnicmp(data, "seal",4) == 0) {
1266 vol->secFlg |= CIFSSEC_MUST_SEAL; */
Steve French50c2f752007-07-13 00:33:32 +00001267 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001269 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001271 } else if (strnicmp(data, "in6_addr", 8) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 if (!value || !*value) {
1273 vol->in6_addr = NULL;
1274 } else if (strnlen(value, 49) == 48) {
1275 vol->in6_addr = value;
1276 } else {
Steve French50c2f752007-07-13 00:33:32 +00001277 printk(KERN_WARNING "CIFS: ip v6 address not "
1278 "48 characters long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 return 1;
1280 }
1281 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001282 printk(KERN_WARNING "CIFS: Mount option noac not "
1283 "supported. Instead set "
1284 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 } else
Steve French50c2f752007-07-13 00:33:32 +00001286 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1287 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
1289 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001290 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001291 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1292 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 return 1;
1294 }
1295 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001296 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001297 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001299 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 if (strncmp(vol->UNC, "//", 2) == 0) {
1301 vol->UNC[0] = '\\';
1302 vol->UNC[1] = '\\';
1303 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001304 printk(KERN_WARNING "CIFS: UNC Path does not "
1305 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 return 1;
1307 }
1308 } else {
1309 printk(KERN_WARNING "CIFS: UNC name too long\n");
1310 return 1;
1311 }
1312 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001313 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 vol->UNCip = &vol->UNC[2];
1315
1316 return 0;
1317}
1318
1319static struct cifsSesInfo *
Steve French50c2f752007-07-13 00:33:32 +00001320cifs_find_tcp_session(struct in_addr *target_ip_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 struct in6_addr *target_ip6_addr,
1322 char *userName, struct TCP_Server_Info **psrvTcp)
1323{
1324 struct list_head *tmp;
1325 struct cifsSesInfo *ses;
1326 *psrvTcp = NULL;
1327 read_lock(&GlobalSMBSeslock);
1328
1329 list_for_each(tmp, &GlobalSMBSessionList) {
1330 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1331 if (ses->server) {
Steve French50c2f752007-07-13 00:33:32 +00001332 if ((target_ip_addr &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 (ses->server->addr.sockAddr.sin_addr.s_addr
1334 == target_ip_addr->s_addr)) || (target_ip6_addr
1335 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
Steve French50c2f752007-07-13 00:33:32 +00001336 target_ip6_addr, sizeof(*target_ip6_addr)))) {
1337 /* BB lock server and tcp session and increment
1338 use count here?? */
1339
1340 /* found a match on the TCP session */
1341 *psrvTcp = ses->server;
1342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 /* BB check if reconnection needed */
1344 if (strncmp
1345 (ses->userName, userName,
1346 MAX_USERNAME_SIZE) == 0){
1347 read_unlock(&GlobalSMBSeslock);
Steve French50c2f752007-07-13 00:33:32 +00001348 /* Found exact match on both TCP and
1349 SMB sessions */
1350 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 }
1352 }
1353 }
1354 /* else tcp and smb sessions need reconnection */
1355 }
1356 read_unlock(&GlobalSMBSeslock);
1357 return NULL;
1358}
1359
1360static struct cifsTconInfo *
1361find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1362{
1363 struct list_head *tmp;
1364 struct cifsTconInfo *tcon;
1365
1366 read_lock(&GlobalSMBSeslock);
1367 list_for_each(tmp, &GlobalTreeConnectionList) {
Steve Frenche466e482006-08-15 13:07:18 +00001368 cFYI(1, ("Next tcon"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1370 if (tcon->ses) {
1371 if (tcon->ses->server) {
1372 cFYI(1,
Steve Frenche466e482006-08-15 13:07:18 +00001373 ("old ip addr: %x == new ip %x ?",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 tcon->ses->server->addr.sockAddr.sin_addr.
1375 s_addr, new_target_ip_addr));
1376 if (tcon->ses->server->addr.sockAddr.sin_addr.
1377 s_addr == new_target_ip_addr) {
Steve Frenche466e482006-08-15 13:07:18 +00001378 /* BB lock tcon, server and tcp session and increment use count here? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 /* found a match on the TCP session */
1380 /* BB check if reconnection needed */
Steve French50c2f752007-07-13 00:33:32 +00001381 cFYI(1,
1382 ("IP match, old UNC: %s new: %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 tcon->treeName, uncName));
1384 if (strncmp
1385 (tcon->treeName, uncName,
1386 MAX_TREE_SIZE) == 0) {
1387 cFYI(1,
Steve Frenche466e482006-08-15 13:07:18 +00001388 ("and old usr: %s new: %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 tcon->treeName, uncName));
1390 if (strncmp
1391 (tcon->ses->userName,
1392 userName,
1393 MAX_USERNAME_SIZE) == 0) {
1394 read_unlock(&GlobalSMBSeslock);
Steve Frenche466e482006-08-15 13:07:18 +00001395 /* matched smb session
1396 (user name */
1397 return tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 }
1399 }
1400 }
1401 }
1402 }
1403 }
1404 read_unlock(&GlobalSMBSeslock);
1405 return NULL;
1406}
1407
1408int
1409connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
Steve French737b7582005-04-28 22:41:06 -07001410 const char *old_path, const struct nls_table *nls_codepage,
1411 int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412{
Steve French366781c2008-01-25 10:12:41 +00001413 struct dfs_info3_param *referrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 unsigned int num_referrals;
1415 int rc = 0;
1416
Steve French50c2f752007-07-13 00:33:32 +00001417 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
Steve French737b7582005-04-28 22:41:06 -07001418 &num_referrals, &referrals, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
1420 /* BB Add in code to: if valid refrl, if not ip address contact
Steve French50c2f752007-07-13 00:33:32 +00001421 the helper that resolves tcp names, mount to it, try to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 tcon to it unmount it if fail */
1423
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001424 kfree(referrals);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
1426 return rc;
1427}
1428
1429int
Steve French50c2f752007-07-13 00:33:32 +00001430get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1431 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00001432 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433{
1434 char *temp_unc;
1435 int rc = 0;
Steve French366781c2008-01-25 10:12:41 +00001436 unsigned char *targetUNCs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
1438 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00001439 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441 if (pSesInfo->ipc_tid == 0) {
1442 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00001443 strnlen(pSesInfo->serverName,
1444 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 + 1 + 4 /* slash IPC$ */ + 2,
1446 GFP_KERNEL);
1447 if (temp_unc == NULL)
1448 return -ENOMEM;
1449 temp_unc[0] = '\\';
1450 temp_unc[1] = '\\';
1451 strcpy(temp_unc + 2, pSesInfo->serverName);
1452 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1453 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1454 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00001455 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 kfree(temp_unc);
1457 }
1458 if (rc == 0)
Steve French366781c2008-01-25 10:12:41 +00001459 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
Steve French737b7582005-04-28 22:41:06 -07001460 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00001461 /* BB map targetUNCs to dfs_info3 structures, here or
1462 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
1464 return rc;
1465}
1466
1467/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00001468static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469{
Steve French50c2f752007-07-13 00:33:32 +00001470 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
Steve French50c2f752007-07-13 00:33:32 +00001472 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 /* mask a nibble at a time and encode */
1474 target[j] = 'A' + (0x0F & (source[i] >> 4));
1475 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00001476 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 }
1478
1479}
1480
1481
1482static int
Steve French50c2f752007-07-13 00:33:32 +00001483ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1484 char *netbios_name, char *target_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485{
1486 int rc = 0;
1487 int connected = 0;
1488 __be16 orig_port = 0;
1489
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001490 if (*csocket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001491 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1492 IPPROTO_TCP, csocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001494 cERROR(1, ("Error %d creating socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 *csocket = NULL;
1496 return rc;
1497 } else {
1498 /* BB other socket options to set KEEPALIVE, NODELAY? */
Steve French467a8f82007-06-27 22:41:32 +00001499 cFYI(1, ("Socket created"));
Steve French50c2f752007-07-13 00:33:32 +00001500 (*csocket)->sk->sk_allocation = GFP_NOFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 }
1502 }
1503
1504 psin_server->sin_family = AF_INET;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001505 if (psin_server->sin_port) { /* user overrode default port */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 rc = (*csocket)->ops->connect(*csocket,
1507 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001508 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 if (rc >= 0)
1510 connected = 1;
Steve French50c2f752007-07-13 00:33:32 +00001511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001513 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001514 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 later if fall back ports fail this time */
1516 orig_port = psin_server->sin_port;
1517
1518 /* do not retry on the same port we just failed on */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001519 if (psin_server->sin_port != htons(CIFS_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 psin_server->sin_port = htons(CIFS_PORT);
1521
1522 rc = (*csocket)->ops->connect(*csocket,
1523 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001524 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 if (rc >= 0)
1526 connected = 1;
1527 }
1528 }
1529 if (!connected) {
1530 psin_server->sin_port = htons(RFC1001_PORT);
1531 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
Steve French50c2f752007-07-13 00:33:32 +00001532 psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001533 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00001534 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 connected = 1;
1536 }
1537
1538 /* give up here - unless we want to retry on different
1539 protocol families some day */
1540 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001541 if (orig_port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 psin_server->sin_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001543 cFYI(1, ("Error %d connecting to server via ipv4", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 sock_release(*csocket);
1545 *csocket = NULL;
1546 return rc;
1547 }
Steve French50c2f752007-07-13 00:33:32 +00001548 /* Eventually check for other socket options to change from
1549 the default. sock_setsockopt not used because it expects
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 user space buffer */
Steve French50c2f752007-07-13 00:33:32 +00001551 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1552 (*csocket)->sk->sk_sndbuf,
Steve Frenchb387eae2005-10-10 14:21:15 -07001553 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchb387eae2005-10-10 14:21:15 -07001555 /* make the bufsizes depend on wsize/rsize and max requests */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001556 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
Steve Frenchb387eae2005-10-10 14:21:15 -07001557 (*csocket)->sk->sk_sndbuf = 200 * 1024;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001558 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
Steve Frenchb387eae2005-10-10 14:21:15 -07001559 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
1561 /* send RFC1001 sessinit */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001562 if (psin_server->sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00001564 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00001566 struct rfc1002_session_packet *ses_init_buf;
1567 struct smb_hdr *smb_buf;
1568 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1569 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001570 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 ses_init_buf->trailer.session_req.called_len = 32;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001572 if (target_name && (target_name[0] != 0)) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001573 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1574 target_name, 16);
1575 } else {
1576 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
Steve French50c2f752007-07-13 00:33:32 +00001577 DEFAULT_CIFS_CALLED_NAME, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001578 }
1579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 ses_init_buf->trailer.session_req.calling_len = 32;
1581 /* calling name ends in null (byte 16) from old smb
1582 convention. */
Steve French50c2f752007-07-13 00:33:32 +00001583 if (netbios_name && (netbios_name[0] != 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
Steve French50c2f752007-07-13 00:33:32 +00001585 netbios_name, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 } else {
1587 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
Steve French50c2f752007-07-13 00:33:32 +00001588 "LINUX_CIFS_CLNT", 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 }
1590 ses_init_buf->trailer.session_req.scope1 = 0;
1591 ses_init_buf->trailer.session_req.scope2 = 0;
1592 smb_buf = (struct smb_hdr *)ses_init_buf;
1593 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1594 smb_buf->smb_buf_length = 0x81000044;
1595 rc = smb_send(*csocket, smb_buf, 0x44,
1596 (struct sockaddr *)psin_server);
1597 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00001598 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00001599 requires very short break before negprot
1600 presumably because not expecting negprot
1601 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00001602 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00001603 complicating the code and causes no
1604 significant slowing down on mount
1605 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 }
Steve French50c2f752007-07-13 00:33:32 +00001607 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00001609
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 }
Steve French50c2f752007-07-13 00:33:32 +00001611
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 return rc;
1613}
1614
1615static int
1616ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1617{
1618 int rc = 0;
1619 int connected = 0;
1620 __be16 orig_port = 0;
1621
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001622 if (*csocket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001623 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1624 IPPROTO_TCP, csocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001626 cERROR(1, ("Error %d creating ipv6 socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 *csocket = NULL;
1628 return rc;
1629 } else {
1630 /* BB other socket options to set KEEPALIVE, NODELAY? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001631 cFYI(1, ("ipv6 Socket created"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 (*csocket)->sk->sk_allocation = GFP_NOFS;
1633 }
1634 }
1635
1636 psin_server->sin6_family = AF_INET6;
1637
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001638 if (psin_server->sin6_port) { /* user overrode default port */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 rc = (*csocket)->ops->connect(*csocket,
1640 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001641 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 if (rc >= 0)
1643 connected = 1;
Steve French50c2f752007-07-13 00:33:32 +00001644 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001646 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001647 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 later if fall back ports fail this time */
1649
1650 orig_port = psin_server->sin6_port;
1651 /* do not retry on the same port we just failed on */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001652 if (psin_server->sin6_port != htons(CIFS_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 psin_server->sin6_port = htons(CIFS_PORT);
1654
1655 rc = (*csocket)->ops->connect(*csocket,
1656 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001657 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 if (rc >= 0)
1659 connected = 1;
1660 }
1661 }
1662 if (!connected) {
1663 psin_server->sin6_port = htons(RFC1001_PORT);
1664 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001665 psin_server, sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00001666 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 connected = 1;
1668 }
1669
1670 /* give up here - unless we want to retry on different
1671 protocol families some day */
1672 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001673 if (orig_port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 psin_server->sin6_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001675 cFYI(1, ("Error %d connecting to server via ipv6", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 sock_release(*csocket);
1677 *csocket = NULL;
1678 return rc;
1679 }
Steve French50c2f752007-07-13 00:33:32 +00001680 /* Eventually check for other socket options to change from
1681 the default. sock_setsockopt not used because it expects
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 user space buffer */
1683 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
Steve French50c2f752007-07-13 00:33:32 +00001684
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 return rc;
1686}
1687
Steve French50c2f752007-07-13 00:33:32 +00001688void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1689 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00001690{
1691 /* if we are reconnecting then should we check to see if
1692 * any requested capabilities changed locally e.g. via
1693 * remount but we can not do much about it here
1694 * if they have (even if we could detect it by the following)
1695 * Perhaps we could add a backpointer to array of sb from tcon
1696 * or if we change to make all sb to same share the same
1697 * sb as NFS - then we only have one backpointer to sb.
1698 * What if we wanted to mount the server share twice once with
1699 * and once without posixacls or posix paths? */
1700 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001701
Steve Frenchc18c8422007-07-18 23:21:09 +00001702 if (vol_info && vol_info->no_linux_ext) {
1703 tcon->fsUnixInfo.Capability = 0;
1704 tcon->unix_ext = 0; /* Unix Extensions disabled */
1705 cFYI(1, ("Linux protocol extensions disabled"));
1706 return;
1707 } else if (vol_info)
1708 tcon->unix_ext = 1; /* Unix Extensions supported */
1709
1710 if (tcon->unix_ext == 0) {
1711 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1712 return;
1713 }
Steve French50c2f752007-07-13 00:33:32 +00001714
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001715 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00001716 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001717
Steve French8af18972007-02-14 04:42:51 +00001718 /* check for reconnect case in which we do not
1719 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001720 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001721 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00001722 originally at mount time */
1723 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1724 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00001725 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1726 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1727 cERROR(1, ("POSIXPATH support change"));
Steve French8af18972007-02-14 04:42:51 +00001728 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00001729 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1730 cERROR(1, ("possible reconnect error"));
1731 cERROR(1,
1732 ("server disabled POSIX path support"));
1733 }
Steve French8af18972007-02-14 04:42:51 +00001734 }
Steve French50c2f752007-07-13 00:33:32 +00001735
Steve French8af18972007-02-14 04:42:51 +00001736 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00001737 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00001738 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00001739 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001740 cFYI(1, ("negotiated posix acl support"));
1741 if (sb)
Steve French8af18972007-02-14 04:42:51 +00001742 sb->s_flags |= MS_POSIXACL;
1743 }
1744
Steve French75865f8c2007-06-24 18:30:48 +00001745 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00001746 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00001747 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001748 cFYI(1, ("negotiate posix pathnames"));
Steve French75865f8c2007-06-24 18:30:48 +00001749 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00001750 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00001751 CIFS_MOUNT_POSIX_PATHS;
1752 }
Steve French50c2f752007-07-13 00:33:32 +00001753
Steve French984acfe2007-04-26 16:42:50 +00001754 /* We might be setting the path sep back to a different
1755 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00001756 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00001757 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00001758 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00001759
1760 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1761 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1762 CIFS_SB(sb)->rsize = 127 * 1024;
Steve French90c81e02008-02-12 20:32:36 +00001763 cFYI(DBG2,
1764 ("larger reads not supported by srv"));
Steve French75865f8c2007-06-24 18:30:48 +00001765 }
1766 }
Steve French50c2f752007-07-13 00:33:32 +00001767
1768
1769 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
Steve French8af18972007-02-14 04:42:51 +00001770#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00001771 if (cap & CIFS_UNIX_FCNTL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001772 cFYI(1, ("FCNTL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001773 if (cap & CIFS_UNIX_EXTATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001774 cFYI(1, ("EXTATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001775 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001776 cFYI(1, ("POSIX path cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001777 if (cap & CIFS_UNIX_XATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001778 cFYI(1, ("XATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001779 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001780 cFYI(1, ("POSIX ACL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001781 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001782 cFYI(1, ("very large read cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001783 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001784 cFYI(1, ("very large write cap"));
Steve French8af18972007-02-14 04:42:51 +00001785#endif /* CIFS_DEBUG2 */
1786 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00001787 if (vol_info == NULL) {
Steve French5a44b312007-09-20 15:16:24 +00001788 cFYI(1, ("resetting capabilities failed"));
Steve French442aa312007-09-24 20:25:46 +00001789 } else
Steve French5a44b312007-09-20 15:16:24 +00001790 cERROR(1, ("Negotiating Unix capabilities "
1791 "with the server failed. Consider "
1792 "mounting with the Unix Extensions\n"
1793 "disabled, if problems are found, "
1794 "by specifying the nounix mount "
Steve French2224f4e2007-09-20 15:37:29 +00001795 "option."));
Steve French5a44b312007-09-20 15:16:24 +00001796
Steve French8af18972007-02-14 04:42:51 +00001797 }
1798 }
1799}
1800
Steve French03a143c2008-02-14 06:38:30 +00001801static void
1802convert_delimiter(char *path, char delim)
1803{
1804 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00001805 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00001806
1807 if (path == NULL)
1808 return;
1809
Steve Frenchc2d68ea2008-02-15 19:20:18 +00001810 if (delim == '/')
1811 old_delim = '\\';
1812 else
1813 old_delim = '/';
1814
Steve French03a143c2008-02-14 06:38:30 +00001815 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00001816 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00001817 path[i] = delim;
1818 }
1819}
1820
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821int
1822cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1823 char *mount_data, const char *devname)
1824{
1825 int rc = 0;
1826 int xid;
1827 int address_type = AF_INET;
1828 struct socket *csocket = NULL;
1829 struct sockaddr_in sin_server;
1830 struct sockaddr_in6 sin_server6;
1831 struct smb_vol volume_info;
1832 struct cifsSesInfo *pSesInfo = NULL;
1833 struct cifsSesInfo *existingCifsSes = NULL;
1834 struct cifsTconInfo *tcon = NULL;
1835 struct TCP_Server_Info *srvTcp = NULL;
1836
1837 xid = GetXid();
1838
1839/* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
Steve French50c2f752007-07-13 00:33:32 +00001840
1841 memset(&volume_info, 0, sizeof(struct smb_vol));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001843 rc = -EINVAL;
1844 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 }
1846
Jeff Layton8426c392007-05-05 03:27:49 +00001847 if (volume_info.nullauth) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001848 cFYI(1, ("null user"));
Jeff Layton9b8f5f52007-11-09 23:25:04 +00001849 volume_info.username = "";
Jeff Layton8426c392007-05-05 03:27:49 +00001850 } else if (volume_info.username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 /* BB fixme parse for domain name here */
Steve French467a8f82007-06-27 22:41:32 +00001852 cFYI(1, ("Username: %s", volume_info.username));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08001854 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00001855 /* In userspace mount helper we can get user name from alternate
1856 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001857 rc = -EINVAL;
1858 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 }
1860
1861 if (volume_info.UNCip && volume_info.UNC) {
Steve French50c2f752007-07-13 00:33:32 +00001862 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1863 &sin_server.sin_addr.s_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001865 if (rc <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 /* not ipv4 address, try ipv6 */
Steve French50c2f752007-07-13 00:33:32 +00001867 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1868 &sin_server6.sin6_addr.in6_u);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001869 if (rc > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 address_type = AF_INET6;
1871 } else {
1872 address_type = AF_INET;
1873 }
Steve French50c2f752007-07-13 00:33:32 +00001874
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001875 if (rc <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 /* we failed translating address */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001877 rc = -EINVAL;
1878 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 }
1880
1881 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1882 /* success */
1883 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001884 } else if (volume_info.UNCip) {
1885 /* BB using ip addr as server name to connect to the
1886 DFS root below */
1887 cERROR(1, ("Connecting to DFS root not implemented yet"));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001888 rc = -EINVAL;
1889 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 } else /* which servers DFS root would we conect to */ {
1891 cERROR(1,
Steve French50c2f752007-07-13 00:33:32 +00001892 ("CIFS mount error: No UNC path (e.g. -o "
1893 "unc=//192.168.1.100/public) specified"));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001894 rc = -EINVAL;
1895 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 }
1897
1898 /* this is needed for ASCII cp to Unicode converts */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001899 if (volume_info.iocharset == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 cifs_sb->local_nls = load_nls_default();
1901 /* load_nls_default can not return null */
1902 } else {
1903 cifs_sb->local_nls = load_nls(volume_info.iocharset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001904 if (cifs_sb->local_nls == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001905 cERROR(1, ("CIFS mount error: iocharset %s not found",
1906 volume_info.iocharset));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001907 rc = -ELIBACC;
1908 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 }
1910 }
1911
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001912 if (address_type == AF_INET)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1914 NULL /* no ipv6 addr */,
1915 volume_info.username, &srvTcp);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001916 else if (address_type == AF_INET6) {
1917 cFYI(1, ("looking for ipv6 address"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1919 &sin_server6.sin6_addr,
1920 volume_info.username, &srvTcp);
Steve French5858ae42007-04-25 11:59:10 +00001921 } else {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001922 rc = -EINVAL;
1923 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 }
1925
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 if (srvTcp) {
Steve French50c2f752007-07-13 00:33:32 +00001927 cFYI(1, ("Existing tcp session with server found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 } else { /* create socket */
Steve French4523cc32007-04-30 20:13:06 +00001929 if (volume_info.port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 sin_server.sin_port = htons(volume_info.port);
1931 else
1932 sin_server.sin_port = 0;
Steve French5858ae42007-04-25 11:59:10 +00001933 if (address_type == AF_INET6) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001934 cFYI(1, ("attempting ipv6 connect"));
Steve French5858ae42007-04-25 11:59:10 +00001935 /* BB should we allow ipv6 on port 139? */
1936 /* other OS never observed in Wild doing 139 with v6 */
Steve French50c2f752007-07-13 00:33:32 +00001937 rc = ipv6_connect(&sin_server6, &csocket);
1938 } else
1939 rc = ipv4_connect(&sin_server, &csocket,
Steve Frencha10faeb22005-08-22 21:38:31 -07001940 volume_info.source_rfc1001_name,
1941 volume_info.target_rfc1001_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001943 cERROR(1, ("Error connecting to IPv4 socket. "
1944 "Aborting operation"));
Steve French4523cc32007-04-30 20:13:06 +00001945 if (csocket != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 sock_release(csocket);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001947 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 }
1949
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00001950 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1951 if (!srvTcp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 rc = -ENOMEM;
1953 sock_release(csocket);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001954 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 } else {
Steve French50c2f752007-07-13 00:33:32 +00001956 memcpy(&srvTcp->addr.sockAddr, &sin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001957 sizeof(struct sockaddr_in));
Steve French50c2f752007-07-13 00:33:32 +00001958 atomic_set(&srvTcp->inFlight, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 /* BB Add code for ipv6 case too */
1960 srvTcp->ssocket = csocket;
1961 srvTcp->protocolType = IPV4;
Jeff Laytonc359cf32007-11-16 22:22:06 +00001962 srvTcp->hostname = extract_hostname(volume_info.UNC);
1963 if (IS_ERR(srvTcp->hostname)) {
1964 rc = PTR_ERR(srvTcp->hostname);
1965 sock_release(csocket);
1966 goto out;
1967 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 init_waitqueue_head(&srvTcp->response_q);
1969 init_waitqueue_head(&srvTcp->request_q);
1970 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1971 /* at this point we are the only ones with the pointer
1972 to the struct since the kernel thread not created yet
1973 so no need to spinlock this init of tcpStatus */
1974 srvTcp->tcpStatus = CifsNew;
1975 init_MUTEX(&srvTcp->tcpSem);
Igor Mammedovaaf737a2007-04-03 19:16:43 +00001976 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
Steve French8840dee2007-11-16 23:05:52 +00001977 if (IS_ERR(srvTcp->tsk)) {
Igor Mammedovaaf737a2007-04-03 19:16:43 +00001978 rc = PTR_ERR(srvTcp->tsk);
Steve French50c2f752007-07-13 00:33:32 +00001979 cERROR(1, ("error %d create cifsd thread", rc));
Igor Mammedovaaf737a2007-04-03 19:16:43 +00001980 srvTcp->tsk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 sock_release(csocket);
Jeff Laytonc359cf32007-11-16 22:22:06 +00001982 kfree(srvTcp->hostname);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001983 goto out;
Steve Frenchf1914012005-08-18 09:37:34 -07001984 }
1985 wait_for_completion(&cifsd_complete);
1986 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001987 memcpy(srvTcp->workstation_RFC1001_name,
1988 volume_info.source_rfc1001_name, 16);
1989 memcpy(srvTcp->server_RFC1001_name,
1990 volume_info.target_rfc1001_name, 16);
Steve Frenchad009ac2005-04-28 22:41:05 -07001991 srvTcp->sequence_number = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 }
1993 }
1994
1995 if (existingCifsSes) {
1996 pSesInfo = existingCifsSes;
Jeff Layton1d9a8852007-12-31 01:37:11 +00001997 cFYI(1, ("Existing smb sess found (status=%d)",
1998 pSesInfo->status));
Steve French88e7d702008-01-03 17:37:09 +00001999 down(&pSesInfo->sesSem);
Jeff Layton1d9a8852007-12-31 01:37:11 +00002000 if (pSesInfo->status == CifsNeedReconnect) {
2001 cFYI(1, ("Session needs reconnect"));
Jeff Layton1d9a8852007-12-31 01:37:11 +00002002 rc = cifs_setup_session(xid, pSesInfo,
2003 cifs_sb->local_nls);
Jeff Layton1d9a8852007-12-31 01:37:11 +00002004 }
Steve French88e7d702008-01-03 17:37:09 +00002005 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 } else if (!rc) {
Steve Frenchbf820672005-12-01 22:32:42 -08002007 cFYI(1, ("Existing smb sess not found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 pSesInfo = sesInfoAlloc();
2009 if (pSesInfo == NULL)
2010 rc = -ENOMEM;
2011 else {
2012 pSesInfo->server = srvTcp;
2013 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2014 NIPQUAD(sin_server.sin_addr.s_addr));
2015 }
2016
Steve French50c2f752007-07-13 00:33:32 +00002017 if (!rc) {
2018 /* volume_info.password freed at unmount */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002019 if (volume_info.password) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 pSesInfo->password = volume_info.password;
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002021 /* set to NULL to prevent freeing on exit */
2022 volume_info.password = NULL;
2023 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 if (volume_info.username)
2025 strncpy(pSesInfo->userName,
Steve French50c2f752007-07-13 00:33:32 +00002026 volume_info.username,
2027 MAX_USERNAME_SIZE);
Steve French39798772006-05-31 22:40:51 +00002028 if (volume_info.domainname) {
2029 int len = strlen(volume_info.domainname);
Steve French50c2f752007-07-13 00:33:32 +00002030 pSesInfo->domainName =
Steve French39798772006-05-31 22:40:51 +00002031 kmalloc(len + 1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00002032 if (pSesInfo->domainName)
Steve French39798772006-05-31 22:40:51 +00002033 strcpy(pSesInfo->domainName,
2034 volume_info.domainname);
2035 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 pSesInfo->linux_uid = volume_info.linux_uid;
Steve French750d1152006-06-27 06:28:30 +00002037 pSesInfo->overrideSecFlg = volume_info.secFlg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 down(&pSesInfo->sesSem);
Steve French189acaa2006-06-23 02:33:48 +00002039 /* BB FIXME need to pass vol->secFlgs BB */
Steve French50c2f752007-07-13 00:33:32 +00002040 rc = cifs_setup_session(xid, pSesInfo,
2041 cifs_sb->local_nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 up(&pSesInfo->sesSem);
Steve French4523cc32007-04-30 20:13:06 +00002043 if (!rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 atomic_inc(&srvTcp->socketUseCount);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 }
Steve French50c2f752007-07-13 00:33:32 +00002047
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 /* search for existing tcon to this server share */
2049 if (!rc) {
Steve French4523cc32007-04-30 20:13:06 +00002050 if (volume_info.rsize > CIFSMaxBufSize) {
Steve French50c2f752007-07-13 00:33:32 +00002051 cERROR(1, ("rsize %d too large, using MaxBufSize",
Steve French0ae0efa2005-10-10 10:57:19 -07002052 volume_info.rsize));
2053 cifs_sb->rsize = CIFSMaxBufSize;
Steve French75865f8c2007-06-24 18:30:48 +00002054 } else if ((volume_info.rsize) &&
2055 (volume_info.rsize <= CIFSMaxBufSize))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 cifs_sb->rsize = volume_info.rsize;
Steve French0ae0efa2005-10-10 10:57:19 -07002057 else /* default */
2058 cifs_sb->rsize = CIFSMaxBufSize;
2059
Steve French4523cc32007-04-30 20:13:06 +00002060 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
Steve French50c2f752007-07-13 00:33:32 +00002061 cERROR(1, ("wsize %d too large, using 4096 instead",
Steve French0ae0efa2005-10-10 10:57:19 -07002062 volume_info.wsize));
2063 cifs_sb->wsize = 4096;
Steve French4523cc32007-04-30 20:13:06 +00002064 } else if (volume_info.wsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 cifs_sb->wsize = volume_info.wsize;
2066 else
Steve French50c2f752007-07-13 00:33:32 +00002067 cifs_sb->wsize =
Steve French1877c9e2006-01-27 18:36:11 -08002068 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2069 127*1024);
Steve French17cbbaf2006-01-24 20:26:48 -08002070 /* old default of CIFSMaxBufSize was too small now
Steve French50c2f752007-07-13 00:33:32 +00002071 that SMB Write2 can send multiple pages in kvec.
Steve French17cbbaf2006-01-24 20:26:48 -08002072 RFC1001 does not describe what happens when frame
2073 bigger than 128K is sent so use that as max in
2074 conjunction with 52K kvec constraint on arch with 4K
2075 page size */
2076
Steve French4523cc32007-04-30 20:13:06 +00002077 if (cifs_sb->rsize < 2048) {
Steve French50c2f752007-07-13 00:33:32 +00002078 cifs_sb->rsize = 2048;
Steve French6cec2ae2006-02-22 17:31:52 -06002079 /* Windows ME may prefer this */
Steve French467a8f82007-06-27 22:41:32 +00002080 cFYI(1, ("readsize set to minimum: 2048"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 }
Steve French2fe87f02006-09-21 07:02:52 +00002082 /* calculate prepath */
2083 cifs_sb->prepath = volume_info.prepath;
Steve French4523cc32007-04-30 20:13:06 +00002084 if (cifs_sb->prepath) {
Steve French2fe87f02006-09-21 07:02:52 +00002085 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
Steve French03a143c2008-02-14 06:38:30 +00002086 /* we can not convert the / to \ in the path
2087 separators in the prefixpath yet because we do not
2088 know (until reset_cifs_unix_caps is called later)
2089 whether POSIX PATH CAP is available. We normalize
2090 the / to \ after reset_cifs_unix_caps is called */
Steve French2fe87f02006-09-21 07:02:52 +00002091 volume_info.prepath = NULL;
Steve French50c2f752007-07-13 00:33:32 +00002092 } else
Steve French2fe87f02006-09-21 07:02:52 +00002093 cifs_sb->prepathlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 cifs_sb->mnt_uid = volume_info.linux_uid;
2095 cifs_sb->mnt_gid = volume_info.linux_gid;
2096 cifs_sb->mnt_file_mode = volume_info.file_mode;
2097 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
Steve French467a8f82007-06-27 22:41:32 +00002098 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2099 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100
Steve French4523cc32007-04-30 20:13:06 +00002101 if (volume_info.noperm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
Steve French4523cc32007-04-30 20:13:06 +00002103 if (volume_info.setuids)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
Steve French4523cc32007-04-30 20:13:06 +00002105 if (volume_info.server_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
Steve French4523cc32007-04-30 20:13:06 +00002107 if (volume_info.remap)
Steve French6a0b4822005-04-28 22:41:05 -07002108 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
Steve French4523cc32007-04-30 20:13:06 +00002109 if (volume_info.no_xattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
Steve French4523cc32007-04-30 20:13:06 +00002111 if (volume_info.sfu_emul)
Steve Frenchd7245c22005-07-14 18:25:12 -05002112 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
Steve French4523cc32007-04-30 20:13:06 +00002113 if (volume_info.nobrl)
Steve Frenchc46fa8a2005-08-18 20:49:57 -07002114 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve French4523cc32007-04-30 20:13:06 +00002115 if (volume_info.cifs_acl)
Steve French0a4b92c2006-01-12 15:44:21 -08002116 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Steve French4523cc32007-04-30 20:13:06 +00002117 if (volume_info.override_uid)
2118 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2119 if (volume_info.override_gid)
2120 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2121 if (volume_info.direct_io) {
Steve French467a8f82007-06-27 22:41:32 +00002122 cFYI(1, ("mounting share using direct i/o"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2124 }
2125
2126 tcon =
2127 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2128 volume_info.username);
2129 if (tcon) {
Steve Frenchbf820672005-12-01 22:32:42 -08002130 cFYI(1, ("Found match on UNC path"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 /* we can have only one retry value for a connection
2132 to a share so for resources mounted more than once
Steve French50c2f752007-07-13 00:33:32 +00002133 to the same server share the last value passed in
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 for the retry flag is used */
2135 tcon->retry = volume_info.retry;
Steve Frenchd3485d32005-08-19 11:04:29 -07002136 tcon->nocase = volume_info.nocase;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 } else {
2138 tcon = tconInfoAlloc();
2139 if (tcon == NULL)
2140 rc = -ENOMEM;
2141 else {
Steve French50c2f752007-07-13 00:33:32 +00002142 /* check for null share name ie connecting to
Steve French8af18972007-02-14 04:42:51 +00002143 * dfs root */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Steve French50c2f752007-07-13 00:33:32 +00002145 /* BB check if this works for exactly length
Steve French8af18972007-02-14 04:42:51 +00002146 * three strings */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2148 && (strchr(volume_info.UNC + 3, '/') ==
2149 NULL)) {
Steve French737b7582005-04-28 22:41:06 -07002150 rc = connect_to_dfs_path(xid, pSesInfo,
Steve French8af18972007-02-14 04:42:51 +00002151 "", cifs_sb->local_nls,
Steve French50c2f752007-07-13 00:33:32 +00002152 cifs_sb->mnt_cifs_flags &
Steve French8af18972007-02-14 04:42:51 +00002153 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002154 rc = -ENODEV;
2155 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 } else {
Steve French8af18972007-02-14 04:42:51 +00002157 /* BB Do we need to wrap sesSem around
2158 * this TCon call and Unix SetFS as
2159 * we do on SessSetup and reconnect? */
Steve French50c2f752007-07-13 00:33:32 +00002160 rc = CIFSTCon(xid, pSesInfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 volume_info.UNC,
2162 tcon, cifs_sb->local_nls);
2163 cFYI(1, ("CIFS Tcon rc = %d", rc));
2164 }
2165 if (!rc) {
2166 atomic_inc(&pSesInfo->inUse);
2167 tcon->retry = volume_info.retry;
Steve Frenchd3485d32005-08-19 11:04:29 -07002168 tcon->nocase = volume_info.nocase;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 }
2170 }
2171 }
2172 }
Steve French4523cc32007-04-30 20:13:06 +00002173 if (pSesInfo) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2175 sb->s_maxbytes = (u64) 1 << 63;
2176 } else
2177 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2178 }
2179
Steve French8af18972007-02-14 04:42:51 +00002180 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 sb->s_time_gran = 100;
2182
2183/* on error free sesinfo and tcon struct if needed */
2184 if (rc) {
2185 /* if session setup failed, use count is zero but
2186 we still need to free cifsd thread */
Steve French4523cc32007-04-30 20:13:06 +00002187 if (atomic_read(&srvTcp->socketUseCount) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 spin_lock(&GlobalMid_Lock);
2189 srvTcp->tcpStatus = CifsExiting;
2190 spin_unlock(&GlobalMid_Lock);
Steve French4523cc32007-04-30 20:13:06 +00002191 if (srvTcp->tsk) {
Steve French28356a12007-05-23 14:45:36 +00002192 struct task_struct *tsk;
2193 /* If we could verify that kthread_stop would
2194 always wake up processes blocked in
2195 tcp in recv_mesg then we could remove the
2196 send_sig call */
Steve French50c2f752007-07-13 00:33:32 +00002197 force_sig(SIGKILL, srvTcp->tsk);
Steve French28356a12007-05-23 14:45:36 +00002198 tsk = srvTcp->tsk;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002199 if (tsk)
Steve Frenchf7f7c312007-05-24 02:29:51 +00002200 kthread_stop(tsk);
Steve Frenchf1914012005-08-18 09:37:34 -07002201 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 }
2203 /* If find_unc succeeded then rc == 0 so we can not end */
2204 if (tcon) /* up accidently freeing someone elses tcon struct */
2205 tconInfoFree(tcon);
2206 if (existingCifsSes == NULL) {
2207 if (pSesInfo) {
Steve French50c2f752007-07-13 00:33:32 +00002208 if ((pSesInfo->server) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 (pSesInfo->status == CifsGood)) {
2210 int temp_rc;
2211 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2212 /* if the socketUseCount is now zero */
Steve French4523cc32007-04-30 20:13:06 +00002213 if ((temp_rc == -ESHUTDOWN) &&
Steve French50c2f752007-07-13 00:33:32 +00002214 (pSesInfo->server) &&
Jeff5d9c7202007-06-25 22:16:35 +00002215 (pSesInfo->server->tsk)) {
Steve French28356a12007-05-23 14:45:36 +00002216 struct task_struct *tsk;
Jeff5d9c7202007-06-25 22:16:35 +00002217 force_sig(SIGKILL,
2218 pSesInfo->server->tsk);
Steve French28356a12007-05-23 14:45:36 +00002219 tsk = pSesInfo->server->tsk;
Steve Frenchf7f7c312007-05-24 02:29:51 +00002220 if (tsk)
Steve French28356a12007-05-23 14:45:36 +00002221 kthread_stop(tsk);
Steve Frenchf1914012005-08-18 09:37:34 -07002222 }
Steve Frencha0136892007-10-04 20:05:09 +00002223 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 cFYI(1, ("No session or bad tcon"));
Steve Frencha0136892007-10-04 20:05:09 +00002225 if ((pSesInfo->server) &&
2226 (pSesInfo->server->tsk)) {
2227 struct task_struct *tsk;
2228 force_sig(SIGKILL,
2229 pSesInfo->server->tsk);
2230 tsk = pSesInfo->server->tsk;
2231 if (tsk)
2232 kthread_stop(tsk);
2233 }
2234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 sesInfoFree(pSesInfo);
2236 /* pSesInfo = NULL; */
2237 }
2238 }
2239 } else {
2240 atomic_inc(&tcon->useCount);
2241 cifs_sb->tcon = tcon;
2242 tcon->ses = pSesInfo;
2243
Steve French82940a42006-03-02 03:24:57 +00002244 /* do not care if following two calls succeed - informational */
Steve French7f8ed422007-09-28 22:28:55 +00002245 if (!tcon->ipc) {
2246 CIFSSMBQFSDeviceInfo(xid, tcon);
2247 CIFSSMBQFSAttributeInfo(xid, tcon);
2248 }
Steve French50c2f752007-07-13 00:33:32 +00002249
Steve French8af18972007-02-14 04:42:51 +00002250 /* tell server which Unix caps we support */
2251 if (tcon->ses->capabilities & CAP_UNIX)
Steve Frenchc18c8422007-07-18 23:21:09 +00002252 /* reset of caps checks mount to see if unix extensions
2253 disabled for just this mount */
Steve French8af18972007-02-14 04:42:51 +00002254 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
Steve Frenchc18c8422007-07-18 23:21:09 +00002255 else
2256 tcon->unix_ext = 0; /* server does not support them */
2257
Steve French03a143c2008-02-14 06:38:30 +00002258 /* convert forward to back slashes in prepath here if needed */
Igor Mammedov11b6d642008-02-15 19:06:04 +00002259 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2260 convert_delimiter(cifs_sb->prepath,
2261 CIFS_DIR_SEP(cifs_sb));
Steve French03a143c2008-02-14 06:38:30 +00002262
Steve Frenchc18c8422007-07-18 23:21:09 +00002263 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
Steve French75865f8c2007-06-24 18:30:48 +00002264 cifs_sb->rsize = 1024 * 127;
Steve French90c81e02008-02-12 20:32:36 +00002265 cFYI(DBG2,
2266 ("no very large read support, rsize now 127K"));
Steve French75865f8c2007-06-24 18:30:48 +00002267 }
Steve French3e844692005-10-03 13:37:24 -07002268 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2269 cifs_sb->wsize = min(cifs_sb->wsize,
2270 (tcon->ses->server->maxBuf -
2271 MAX_CIFS_HDR_SIZE));
Steve French0ae0efa2005-10-10 10:57:19 -07002272 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
Steve French50c2f752007-07-13 00:33:32 +00002273 cifs_sb->rsize = min(cifs_sb->rsize,
2274 (tcon->ses->server->maxBuf -
2275 MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 }
2277
2278 /* volume_info.password is freed above when existing session found
2279 (in which case it is not needed anymore) but when new sesion is created
2280 the password ptr is put in the new session structure (in which case the
2281 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002282out:
2283 /* zero out password before freeing */
2284 if (volume_info.password != NULL) {
2285 memset(volume_info.password, 0, strlen(volume_info.password));
2286 kfree(volume_info.password);
2287 }
Jesper Juhlf99d49a2005-11-07 01:01:34 -08002288 kfree(volume_info.UNC);
Steve French2fe87f02006-09-21 07:02:52 +00002289 kfree(volume_info.prepath);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 FreeXid(xid);
2291 return rc;
2292}
2293
2294static int
2295CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Steve French7c7b25b2006-06-01 19:20:10 +00002296 char session_key[CIFS_SESS_KEY_SIZE],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 const struct nls_table *nls_codepage)
2298{
2299 struct smb_hdr *smb_buffer;
2300 struct smb_hdr *smb_buffer_response;
2301 SESSION_SETUP_ANDX *pSMB;
2302 SESSION_SETUP_ANDX *pSMBr;
2303 char *bcc_ptr;
2304 char *user;
2305 char *domain;
2306 int rc = 0;
2307 int remaining_words = 0;
2308 int bytes_returned = 0;
2309 int len;
2310 __u32 capabilities;
2311 __u16 count;
2312
Steve Frencheeac8042006-01-13 21:34:58 -08002313 cFYI(1, ("In sesssetup"));
Steve French4523cc32007-04-30 20:13:06 +00002314 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 return -EINVAL;
2316 user = ses->userName;
2317 domain = ses->domainName;
2318 smb_buffer = cifs_buf_get();
2319 if (smb_buffer == NULL) {
2320 return -ENOMEM;
2321 }
2322 smb_buffer_response = smb_buffer;
2323 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2324
2325 /* send SMBsessionSetup here */
2326 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2327 NULL /* no tCon exists yet */ , 13 /* wct */ );
2328
Steve French1982c342005-08-17 12:38:22 -07002329 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 pSMB->req_no_secext.AndXCommand = 0xFF;
2331 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2332 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2333
Steve French50c2f752007-07-13 00:33:32 +00002334 if (ses->server->secMode &
2335 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2337
2338 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2339 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2340 if (ses->capabilities & CAP_UNICODE) {
2341 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2342 capabilities |= CAP_UNICODE;
2343 }
2344 if (ses->capabilities & CAP_STATUS32) {
2345 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2346 capabilities |= CAP_STATUS32;
2347 }
2348 if (ses->capabilities & CAP_DFS) {
2349 smb_buffer->Flags2 |= SMBFLG2_DFS;
2350 capabilities |= CAP_DFS;
2351 }
2352 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2353
Steve French50c2f752007-07-13 00:33:32 +00002354 pSMB->req_no_secext.CaseInsensitivePasswordLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002355 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356
2357 pSMB->req_no_secext.CaseSensitivePasswordLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002358 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 bcc_ptr = pByteArea(smb_buffer);
Steve French7c7b25b2006-06-01 19:20:10 +00002360 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2361 bcc_ptr += CIFS_SESS_KEY_SIZE;
2362 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2363 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364
2365 if (ses->capabilities & CAP_UNICODE) {
2366 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2367 *bcc_ptr = 0;
2368 bcc_ptr++;
2369 }
Steve French4523cc32007-04-30 20:13:06 +00002370 if (user == NULL)
Steve French39798772006-05-31 22:40:51 +00002371 bytes_returned = 0; /* skip null user */
Steve French50c2f752007-07-13 00:33:32 +00002372 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 bytes_returned =
Steve French50c2f752007-07-13 00:33:32 +00002374 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 nls_codepage);
2376 /* convert number of 16 bit words to bytes */
2377 bcc_ptr += 2 * bytes_returned;
2378 bcc_ptr += 2; /* trailing null */
2379 if (domain == NULL)
2380 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002381 cifs_strtoUCS((__le16 *) bcc_ptr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382 "CIFS_LINUX_DOM", 32, nls_codepage);
2383 else
2384 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002385 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 nls_codepage);
2387 bcc_ptr += 2 * bytes_returned;
2388 bcc_ptr += 2;
2389 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002390 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 32, nls_codepage);
2392 bcc_ptr += 2 * bytes_returned;
2393 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002394 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 32, nls_codepage);
2396 bcc_ptr += 2 * bytes_returned;
2397 bcc_ptr += 2;
2398 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002399 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 64, nls_codepage);
2401 bcc_ptr += 2 * bytes_returned;
2402 bcc_ptr += 2;
2403 } else {
Steve French50c2f752007-07-13 00:33:32 +00002404 if (user != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 strncpy(bcc_ptr, user, 200);
2406 bcc_ptr += strnlen(user, 200);
2407 }
2408 *bcc_ptr = 0;
2409 bcc_ptr++;
2410 if (domain == NULL) {
2411 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2412 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2413 } else {
2414 strncpy(bcc_ptr, domain, 64);
2415 bcc_ptr += strnlen(domain, 64);
2416 *bcc_ptr = 0;
2417 bcc_ptr++;
2418 }
2419 strcpy(bcc_ptr, "Linux version ");
2420 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002421 strcpy(bcc_ptr, utsname()->release);
2422 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2424 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2425 }
2426 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2427 smb_buffer->smb_buf_length += count;
2428 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2429
2430 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00002431 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 if (rc) {
2433/* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2434 } else if ((smb_buffer_response->WordCount == 3)
2435 || (smb_buffer_response->WordCount == 4)) {
2436 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2437 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2438 if (action & GUEST_LOGIN)
Steve French50c2f752007-07-13 00:33:32 +00002439 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2440 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2441 (little endian) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 cFYI(1, ("UID = %d ", ses->Suid));
Steve French50c2f752007-07-13 00:33:32 +00002443 /* response can have either 3 or 4 word count - Samba sends 3 */
2444 bcc_ptr = pByteArea(smb_buffer_response);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 if ((pSMBr->resp.hdr.WordCount == 3)
2446 || ((pSMBr->resp.hdr.WordCount == 4)
2447 && (blob_len < pSMBr->resp.ByteCount))) {
2448 if (pSMBr->resp.hdr.WordCount == 4)
2449 bcc_ptr += blob_len;
2450
2451 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2452 if ((long) (bcc_ptr) % 2) {
2453 remaining_words =
Steve French50c2f752007-07-13 00:33:32 +00002454 (BCC(smb_buffer_response) - 1) / 2;
2455 /* Unicode strings must be word
2456 aligned */
2457 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 } else {
2459 remaining_words =
2460 BCC(smb_buffer_response) / 2;
2461 }
2462 len =
2463 UniStrnlen((wchar_t *) bcc_ptr,
2464 remaining_words - 1);
2465/* We look for obvious messed up bcc or strings in response so we do not go off
2466 the end since (at least) WIN2K and Windows XP have a major bug in not null
2467 terminating last Unicode string in response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002468 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00002469 kfree(ses->serverOS);
Steve French50c2f752007-07-13 00:33:32 +00002470 ses->serverOS = kzalloc(2 * (len + 1),
2471 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002472 if (ses->serverOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002473 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 cifs_strfromUCS_le(ses->serverOS,
Steve French50c2f752007-07-13 00:33:32 +00002475 (__le16 *)bcc_ptr,
2476 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 bcc_ptr += 2 * (len + 1);
2478 remaining_words -= len + 1;
2479 ses->serverOS[2 * len] = 0;
2480 ses->serverOS[1 + (2 * len)] = 0;
2481 if (remaining_words > 0) {
2482 len = UniStrnlen((wchar_t *)bcc_ptr,
2483 remaining_words-1);
Steve Frenchcd49b492006-06-26 04:22:36 +00002484 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00002485 ses->serverNOS = kzalloc(2 * (len + 1),
2486 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002487 if (ses->serverNOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002488 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 cifs_strfromUCS_le(ses->serverNOS,
Steve French50c2f752007-07-13 00:33:32 +00002490 (__le16 *)bcc_ptr,
2491 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492 bcc_ptr += 2 * (len + 1);
2493 ses->serverNOS[2 * len] = 0;
2494 ses->serverNOS[1 + (2 * len)] = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002495 if (strncmp(ses->serverNOS,
Steve French50c2f752007-07-13 00:33:32 +00002496 "NT LAN Manager 4", 16) == 0) {
Steve French467a8f82007-06-27 22:41:32 +00002497 cFYI(1, ("NT4 server"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 ses->flags |= CIFS_SES_NT4;
2499 }
2500 remaining_words -= len + 1;
2501 if (remaining_words > 0) {
Steve French433dc242005-04-28 22:41:08 -07002502 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Steve French50c2f752007-07-13 00:33:32 +00002503 /* last string is not always null terminated
2504 (for e.g. for Windows XP & 2000) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002505 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00002506 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507 ses->serverDomain =
Steve French50c2f752007-07-13 00:33:32 +00002508 kzalloc(2*(len+1),
2509 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002510 if (ses->serverDomain == NULL)
Steve French433dc242005-04-28 22:41:08 -07002511 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 cifs_strfromUCS_le(ses->serverDomain,
Steve French50c2f752007-07-13 00:33:32 +00002513 (__le16 *)bcc_ptr,
2514 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 bcc_ptr += 2 * (len + 1);
2516 ses->serverDomain[2*len] = 0;
2517 ses->serverDomain[1+(2*len)] = 0;
Steve French50c2f752007-07-13 00:33:32 +00002518 } else { /* else no more room so create
2519 dummy domain string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002520 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00002521 kfree(ses->serverDomain);
Steve French50c2f752007-07-13 00:33:32 +00002522 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002523 kzalloc(2, GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00002524 }
Steve French50c2f752007-07-13 00:33:32 +00002525 } else { /* no room so create dummy domain
2526 and NOS string */
2527
Steve French433dc242005-04-28 22:41:08 -07002528 /* if these kcallocs fail not much we
2529 can do, but better to not fail the
2530 sesssetup itself */
Steve Frenchcd49b492006-06-26 04:22:36 +00002531 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002533 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00002534 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002536 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537 }
2538 } else { /* ASCII */
2539 len = strnlen(bcc_ptr, 1024);
2540 if (((long) bcc_ptr + len) - (long)
2541 pByteArea(smb_buffer_response)
2542 <= BCC(smb_buffer_response)) {
Steve Frenchcd49b492006-06-26 04:22:36 +00002543 kfree(ses->serverOS);
Steve French50c2f752007-07-13 00:33:32 +00002544 ses->serverOS = kzalloc(len + 1,
2545 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002546 if (ses->serverOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002547 goto sesssetup_nomem;
Steve French50c2f752007-07-13 00:33:32 +00002548 strncpy(ses->serverOS, bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549
2550 bcc_ptr += len;
Steve French50c2f752007-07-13 00:33:32 +00002551 /* null terminate the string */
2552 bcc_ptr[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 bcc_ptr++;
2554
2555 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002556 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00002557 ses->serverNOS = kzalloc(len + 1,
2558 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002559 if (ses->serverNOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002560 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 strncpy(ses->serverNOS, bcc_ptr, len);
2562 bcc_ptr += len;
2563 bcc_ptr[0] = 0;
2564 bcc_ptr++;
2565
2566 len = strnlen(bcc_ptr, 1024);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002567 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00002568 kfree(ses->serverDomain);
Steve French50c2f752007-07-13 00:33:32 +00002569 ses->serverDomain = kzalloc(len + 1,
2570 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002571 if (ses->serverDomain == NULL)
Steve French433dc242005-04-28 22:41:08 -07002572 goto sesssetup_nomem;
Steve French50c2f752007-07-13 00:33:32 +00002573 strncpy(ses->serverDomain, bcc_ptr,
2574 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 bcc_ptr += len;
2576 bcc_ptr[0] = 0;
2577 bcc_ptr++;
2578 } else
2579 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00002580 ("Variable field of length %d "
2581 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 len));
2583 }
2584 } else {
2585 cERROR(1,
Steve French50c2f752007-07-13 00:33:32 +00002586 (" Security Blob Length extends beyond "
2587 "end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 }
2589 } else {
2590 cERROR(1,
2591 (" Invalid Word count %d: ",
2592 smb_buffer_response->WordCount));
2593 rc = -EIO;
2594 }
Steve French433dc242005-04-28 22:41:08 -07002595sesssetup_nomem: /* do not return an error on nomem for the info strings,
2596 since that could make reconnection harder, and
2597 reconnection might be needed to free memory */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002598 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599
2600 return rc;
2601}
2602
2603static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
Steve French50c2f752007-07-13 00:33:32 +00002605 struct cifsSesInfo *ses, int *pNTLMv2_flag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 const struct nls_table *nls_codepage)
2607{
2608 struct smb_hdr *smb_buffer;
2609 struct smb_hdr *smb_buffer_response;
2610 SESSION_SETUP_ANDX *pSMB;
2611 SESSION_SETUP_ANDX *pSMBr;
2612 char *bcc_ptr;
2613 char *domain;
2614 int rc = 0;
2615 int remaining_words = 0;
2616 int bytes_returned = 0;
2617 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002618 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 PNEGOTIATE_MESSAGE SecurityBlob;
2620 PCHALLENGE_MESSAGE SecurityBlob2;
2621 __u32 negotiate_flags, capabilities;
2622 __u16 count;
2623
Steve French12b3b8f2006-02-09 21:12:47 +00002624 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002625 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 return -EINVAL;
2627 domain = ses->domainName;
2628 *pNTLMv2_flag = FALSE;
2629 smb_buffer = cifs_buf_get();
2630 if (smb_buffer == NULL) {
2631 return -ENOMEM;
2632 }
2633 smb_buffer_response = smb_buffer;
2634 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2635 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2636
2637 /* send SMBsessionSetup here */
2638 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2639 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002640
2641 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2643 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2644
2645 pSMB->req.AndXCommand = 0xFF;
2646 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2647 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2648
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002649 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2651
2652 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2653 CAP_EXTENDED_SECURITY;
2654 if (ses->capabilities & CAP_UNICODE) {
2655 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2656 capabilities |= CAP_UNICODE;
2657 }
2658 if (ses->capabilities & CAP_STATUS32) {
2659 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2660 capabilities |= CAP_STATUS32;
2661 }
2662 if (ses->capabilities & CAP_DFS) {
2663 smb_buffer->Flags2 |= SMBFLG2_DFS;
2664 capabilities |= CAP_DFS;
2665 }
2666 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2667
2668 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2669 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2670 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2671 SecurityBlob->MessageType = NtLmNegotiate;
2672 negotiate_flags =
2673 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
Steve French12b3b8f2006-02-09 21:12:47 +00002674 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2675 NTLMSSP_NEGOTIATE_56 |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002677 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002679/* if (ntlmv2_support)
Steve French39798772006-05-31 22:40:51 +00002680 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 /* setup pointers to domain name and workstation name */
2682 bcc_ptr += SecurityBlobLength;
2683
2684 SecurityBlob->WorkstationName.Buffer = 0;
2685 SecurityBlob->WorkstationName.Length = 0;
2686 SecurityBlob->WorkstationName.MaximumLength = 0;
2687
Steve French12b3b8f2006-02-09 21:12:47 +00002688 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2689 along with username on auth request (ie the response to challenge) */
2690 SecurityBlob->DomainName.Buffer = 0;
2691 SecurityBlob->DomainName.Length = 0;
2692 SecurityBlob->DomainName.MaximumLength = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 if (ses->capabilities & CAP_UNICODE) {
2694 if ((long) bcc_ptr % 2) {
2695 *bcc_ptr = 0;
2696 bcc_ptr++;
2697 }
2698
2699 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002700 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 32, nls_codepage);
2702 bcc_ptr += 2 * bytes_returned;
2703 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002704 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 nls_codepage);
2706 bcc_ptr += 2 * bytes_returned;
2707 bcc_ptr += 2; /* null terminate Linux version */
2708 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002709 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 64, nls_codepage);
2711 bcc_ptr += 2 * bytes_returned;
2712 *(bcc_ptr + 1) = 0;
2713 *(bcc_ptr + 2) = 0;
2714 bcc_ptr += 2; /* null terminate network opsys string */
2715 *(bcc_ptr + 1) = 0;
2716 *(bcc_ptr + 2) = 0;
2717 bcc_ptr += 2; /* null domain */
2718 } else { /* ASCII */
2719 strcpy(bcc_ptr, "Linux version ");
2720 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002721 strcpy(bcc_ptr, utsname()->release);
2722 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2724 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2725 bcc_ptr++; /* empty domain field */
2726 *bcc_ptr = 0;
2727 }
2728 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2729 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2730 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2731 smb_buffer->smb_buf_length += count;
2732 pSMB->req.ByteCount = cpu_to_le16(count);
2733
2734 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00002735 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
2737 if (smb_buffer_response->Status.CifsError ==
2738 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2739 rc = 0;
2740
2741 if (rc) {
2742/* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2743 } else if ((smb_buffer_response->WordCount == 3)
2744 || (smb_buffer_response->WordCount == 4)) {
2745 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2746 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2747
2748 if (action & GUEST_LOGIN)
Steve French50c2f752007-07-13 00:33:32 +00002749 cFYI(1, (" Guest login"));
2750 /* Do we want to set anything in SesInfo struct when guest login? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751
Steve French50c2f752007-07-13 00:33:32 +00002752 bcc_ptr = pByteArea(smb_buffer_response);
2753 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754
2755 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2756 if (SecurityBlob2->MessageType != NtLmChallenge) {
2757 cFYI(1,
2758 ("Unexpected NTLMSSP message type received %d",
2759 SecurityBlob2->MessageType));
2760 } else if (ses) {
Steve French50c2f752007-07-13 00:33:32 +00002761 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
Steve French12b3b8f2006-02-09 21:12:47 +00002762 cFYI(1, ("UID = %d", ses->Suid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 if ((pSMBr->resp.hdr.WordCount == 3)
2764 || ((pSMBr->resp.hdr.WordCount == 4)
2765 && (blob_len <
2766 pSMBr->resp.ByteCount))) {
2767
2768 if (pSMBr->resp.hdr.WordCount == 4) {
2769 bcc_ptr += blob_len;
Steve French12b3b8f2006-02-09 21:12:47 +00002770 cFYI(1, ("Security Blob Length %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 blob_len));
2772 }
2773
Steve French12b3b8f2006-02-09 21:12:47 +00002774 cFYI(1, ("NTLMSSP Challenge rcvd"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775
2776 memcpy(ses->server->cryptKey,
2777 SecurityBlob2->Challenge,
2778 CIFS_CRYPTO_KEY_SIZE);
Steve French50c2f752007-07-13 00:33:32 +00002779 if (SecurityBlob2->NegotiateFlags &
Steve French12b3b8f2006-02-09 21:12:47 +00002780 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 *pNTLMv2_flag = TRUE;
2782
Steve French50c2f752007-07-13 00:33:32 +00002783 if ((SecurityBlob2->NegotiateFlags &
2784 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 || (sign_CIFS_PDUs > 1))
Steve French50c2f752007-07-13 00:33:32 +00002786 ses->server->secMode |=
2787 SECMODE_SIGN_REQUIRED;
2788 if ((SecurityBlob2->NegotiateFlags &
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
Steve French50c2f752007-07-13 00:33:32 +00002790 ses->server->secMode |=
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 SECMODE_SIGN_ENABLED;
2792
2793 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2794 if ((long) (bcc_ptr) % 2) {
2795 remaining_words =
2796 (BCC(smb_buffer_response)
2797 - 1) / 2;
Steve French50c2f752007-07-13 00:33:32 +00002798 /* Must word align unicode strings */
2799 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 } else {
2801 remaining_words =
2802 BCC
2803 (smb_buffer_response) / 2;
2804 }
2805 len =
2806 UniStrnlen((wchar_t *) bcc_ptr,
2807 remaining_words - 1);
2808/* We look for obvious messed up bcc or strings in response so we do not go off
2809 the end since (at least) WIN2K and Windows XP have a major bug in not null
2810 terminating last Unicode string in response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002811 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00002812 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002814 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08002816 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 bcc_ptr, len,
2818 nls_codepage);
2819 bcc_ptr += 2 * (len + 1);
2820 remaining_words -= len + 1;
2821 ses->serverOS[2 * len] = 0;
2822 ses->serverOS[1 + (2 * len)] = 0;
2823 if (remaining_words > 0) {
2824 len = UniStrnlen((wchar_t *)
2825 bcc_ptr,
2826 remaining_words
2827 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00002828 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002830 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831 GFP_KERNEL);
2832 cifs_strfromUCS_le(ses->
2833 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08002834 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 bcc_ptr,
2836 len,
2837 nls_codepage);
2838 bcc_ptr += 2 * (len + 1);
2839 ses->serverNOS[2 * len] = 0;
2840 ses->serverNOS[1 +
2841 (2 * len)] = 0;
2842 remaining_words -= len + 1;
2843 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00002844 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2845 /* last string not always null terminated
2846 (for e.g. for Windows XP & 2000) */
Steve Frenchcd49b492006-06-26 04:22:36 +00002847 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002849 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 (len +
2851 1),
2852 GFP_KERNEL);
2853 cifs_strfromUCS_le
Steve Frenche89dc922005-11-11 15:18:19 -08002854 (ses->serverDomain,
2855 (__le16 *)bcc_ptr,
2856 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857 bcc_ptr +=
2858 2 * (len + 1);
Steve Frenche89dc922005-11-11 15:18:19 -08002859 ses->serverDomain[2*len]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 = 0;
Steve Frenche89dc922005-11-11 15:18:19 -08002861 ses->serverDomain
2862 [1 + (2 * len)]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 = 0;
2864 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00002865 else {
Steve Frenchcd49b492006-06-26 04:22:36 +00002866 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002868 kzalloc(2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869 GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00002870 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 } else { /* no room so create dummy domain and NOS string */
Steve Frenchcd49b492006-06-26 04:22:36 +00002872 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002874 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00002875 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002877 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 }
2879 } else { /* ASCII */
2880 len = strnlen(bcc_ptr, 1024);
2881 if (((long) bcc_ptr + len) - (long)
2882 pByteArea(smb_buffer_response)
2883 <= BCC(smb_buffer_response)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002884 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00002885 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002887 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 GFP_KERNEL);
2889 strncpy(ses->serverOS,
2890 bcc_ptr, len);
2891
2892 bcc_ptr += len;
2893 bcc_ptr[0] = 0; /* null terminate string */
2894 bcc_ptr++;
2895
2896 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002897 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002899 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 GFP_KERNEL);
2901 strncpy(ses->serverNOS, bcc_ptr, len);
2902 bcc_ptr += len;
2903 bcc_ptr[0] = 0;
2904 bcc_ptr++;
2905
2906 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002907 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002909 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +00002911 strncpy(ses->serverDomain,
2912 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913 bcc_ptr += len;
2914 bcc_ptr[0] = 0;
2915 bcc_ptr++;
2916 } else
2917 cFYI(1,
Steve French63135e02007-07-17 17:34:02 +00002918 ("field of length %d "
2919 "extends beyond end of smb",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 len));
2921 }
2922 } else {
Steve French50c2f752007-07-13 00:33:32 +00002923 cERROR(1, ("Security Blob Length extends beyond"
2924 " end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925 }
2926 } else {
2927 cERROR(1, ("No session structure passed in."));
2928 }
2929 } else {
2930 cERROR(1,
Steve French5815449d2006-02-14 01:36:20 +00002931 (" Invalid Word count %d:",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 smb_buffer_response->WordCount));
2933 rc = -EIO;
2934 }
2935
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002936 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937
2938 return rc;
2939}
2940static int
2941CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002942 char *ntlm_session_key, int ntlmv2_flag,
2943 const struct nls_table *nls_codepage)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944{
2945 struct smb_hdr *smb_buffer;
2946 struct smb_hdr *smb_buffer_response;
2947 SESSION_SETUP_ANDX *pSMB;
2948 SESSION_SETUP_ANDX *pSMBr;
2949 char *bcc_ptr;
2950 char *user;
2951 char *domain;
2952 int rc = 0;
2953 int remaining_words = 0;
2954 int bytes_returned = 0;
2955 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002956 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 PAUTHENTICATE_MESSAGE SecurityBlob;
2958 __u32 negotiate_flags, capabilities;
2959 __u16 count;
2960
2961 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002962 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 return -EINVAL;
2964 user = ses->userName;
2965 domain = ses->domainName;
2966 smb_buffer = cifs_buf_get();
2967 if (smb_buffer == NULL) {
2968 return -ENOMEM;
2969 }
2970 smb_buffer_response = smb_buffer;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002971 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2972 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002973
2974 /* send SMBsessionSetup here */
2975 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2976 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002977
2978 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2980 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2981 pSMB->req.AndXCommand = 0xFF;
2982 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2983 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2984
2985 pSMB->req.hdr.Uid = ses->Suid;
2986
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002987 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2989
2990 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002991 CAP_EXTENDED_SECURITY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 if (ses->capabilities & CAP_UNICODE) {
2993 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2994 capabilities |= CAP_UNICODE;
2995 }
2996 if (ses->capabilities & CAP_STATUS32) {
2997 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2998 capabilities |= CAP_STATUS32;
2999 }
3000 if (ses->capabilities & CAP_DFS) {
3001 smb_buffer->Flags2 |= SMBFLG2_DFS;
3002 capabilities |= CAP_DFS;
3003 }
3004 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3005
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003006 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3007 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3009 SecurityBlob->MessageType = NtLmAuthenticate;
3010 bcc_ptr += SecurityBlobLength;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003011 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3012 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3013 0x80000000 | NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003014 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003016 if (ntlmv2_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3018
3019/* setup pointers to domain name and workstation name */
3020
3021 SecurityBlob->WorkstationName.Buffer = 0;
3022 SecurityBlob->WorkstationName.Length = 0;
3023 SecurityBlob->WorkstationName.MaximumLength = 0;
3024 SecurityBlob->SessionKey.Length = 0;
3025 SecurityBlob->SessionKey.MaximumLength = 0;
3026 SecurityBlob->SessionKey.Buffer = 0;
3027
3028 SecurityBlob->LmChallengeResponse.Length = 0;
3029 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3030 SecurityBlob->LmChallengeResponse.Buffer = 0;
3031
3032 SecurityBlob->NtChallengeResponse.Length =
Steve French7c7b25b2006-06-01 19:20:10 +00003033 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 SecurityBlob->NtChallengeResponse.MaximumLength =
Steve French7c7b25b2006-06-01 19:20:10 +00003035 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3036 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 SecurityBlob->NtChallengeResponse.Buffer =
3038 cpu_to_le32(SecurityBlobLength);
Steve French7c7b25b2006-06-01 19:20:10 +00003039 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3040 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041
3042 if (ses->capabilities & CAP_UNICODE) {
3043 if (domain == NULL) {
3044 SecurityBlob->DomainName.Buffer = 0;
3045 SecurityBlob->DomainName.Length = 0;
3046 SecurityBlob->DomainName.MaximumLength = 0;
3047 } else {
Steve French77159b42007-08-31 01:10:17 +00003048 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003050 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003052 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053 SecurityBlob->DomainName.Buffer =
3054 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003055 bcc_ptr += ln;
3056 SecurityBlobLength += ln;
3057 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 }
3059 if (user == NULL) {
3060 SecurityBlob->UserName.Buffer = 0;
3061 SecurityBlob->UserName.Length = 0;
3062 SecurityBlob->UserName.MaximumLength = 0;
3063 } else {
Steve French77159b42007-08-31 01:10:17 +00003064 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003066 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 SecurityBlob->UserName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003068 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003069 SecurityBlob->UserName.Buffer =
3070 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003071 bcc_ptr += ln;
3072 SecurityBlobLength += ln;
3073 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 }
3075
Steve French63135e02007-07-17 17:34:02 +00003076 /* SecurityBlob->WorkstationName.Length =
3077 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 SecurityBlob->WorkstationName.Length *= 2;
Steve French63135e02007-07-17 17:34:02 +00003079 SecurityBlob->WorkstationName.MaximumLength =
3080 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3081 SecurityBlob->WorkstationName.Buffer =
3082 cpu_to_le32(SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 bcc_ptr += SecurityBlob->WorkstationName.Length;
3084 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
Steve French63135e02007-07-17 17:34:02 +00003085 SecurityBlob->WorkstationName.Length =
3086 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087
3088 if ((long) bcc_ptr % 2) {
3089 *bcc_ptr = 0;
3090 bcc_ptr++;
3091 }
3092 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003093 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094 32, nls_codepage);
3095 bcc_ptr += 2 * bytes_returned;
3096 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003097 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 nls_codepage);
3099 bcc_ptr += 2 * bytes_returned;
3100 bcc_ptr += 2; /* null term version string */
3101 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003102 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 64, nls_codepage);
3104 bcc_ptr += 2 * bytes_returned;
3105 *(bcc_ptr + 1) = 0;
3106 *(bcc_ptr + 2) = 0;
3107 bcc_ptr += 2; /* null terminate network opsys string */
3108 *(bcc_ptr + 1) = 0;
3109 *(bcc_ptr + 2) = 0;
3110 bcc_ptr += 2; /* null domain */
3111 } else { /* ASCII */
3112 if (domain == NULL) {
3113 SecurityBlob->DomainName.Buffer = 0;
3114 SecurityBlob->DomainName.Length = 0;
3115 SecurityBlob->DomainName.MaximumLength = 0;
3116 } else {
Steve French77159b42007-08-31 01:10:17 +00003117 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3119 strncpy(bcc_ptr, domain, 63);
Steve French77159b42007-08-31 01:10:17 +00003120 ln = strnlen(domain, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003122 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 SecurityBlob->DomainName.Buffer =
3124 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003125 bcc_ptr += ln;
3126 SecurityBlobLength += ln;
3127 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 }
3129 if (user == NULL) {
3130 SecurityBlob->UserName.Buffer = 0;
3131 SecurityBlob->UserName.Length = 0;
3132 SecurityBlob->UserName.MaximumLength = 0;
3133 } else {
Steve French77159b42007-08-31 01:10:17 +00003134 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135 strncpy(bcc_ptr, user, 63);
Steve French77159b42007-08-31 01:10:17 +00003136 ln = strnlen(user, 64);
3137 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 SecurityBlob->UserName.Buffer =
Steve French77159b42007-08-31 01:10:17 +00003139 cpu_to_le32(SecurityBlobLength);
3140 bcc_ptr += ln;
3141 SecurityBlobLength += ln;
3142 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143 }
3144 /* BB fill in our workstation name if known BB */
3145
3146 strcpy(bcc_ptr, "Linux version ");
3147 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003148 strcpy(bcc_ptr, utsname()->release);
3149 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3151 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3152 bcc_ptr++; /* null domain */
3153 *bcc_ptr = 0;
3154 }
3155 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3156 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3157 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3158 smb_buffer->smb_buf_length += count;
3159 pSMB->req.ByteCount = cpu_to_le16(count);
3160
3161 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00003162 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 if (rc) {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003164/* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3165 } else if ((smb_buffer_response->WordCount == 3) ||
3166 (smb_buffer_response->WordCount == 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 __u16 action = le16_to_cpu(pSMBr->resp.Action);
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003168 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 if (action & GUEST_LOGIN)
Steve French50c2f752007-07-13 00:33:32 +00003170 cFYI(1, (" Guest login")); /* BB Should we set anything
3171 in SesInfo struct ? */
3172/* if (SecurityBlob2->MessageType != NtLm??) {
3173 cFYI("Unexpected message type on auth response is %d"));
3174 } */
3175
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176 if (ses) {
3177 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00003178 ("Check challenge UID %d vs auth response UID %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179 ses->Suid, smb_buffer_response->Uid));
Steve French50c2f752007-07-13 00:33:32 +00003180 /* UID left in wire format */
3181 ses->Suid = smb_buffer_response->Uid;
3182 bcc_ptr = pByteArea(smb_buffer_response);
3183 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184 if ((pSMBr->resp.hdr.WordCount == 3)
3185 || ((pSMBr->resp.hdr.WordCount == 4)
3186 && (blob_len <
3187 pSMBr->resp.ByteCount))) {
3188 if (pSMBr->resp.hdr.WordCount == 4) {
3189 bcc_ptr +=
3190 blob_len;
3191 cFYI(1,
3192 ("Security Blob Length %d ",
3193 blob_len));
3194 }
3195
3196 cFYI(1,
3197 ("NTLMSSP response to Authenticate "));
3198
3199 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3200 if ((long) (bcc_ptr) % 2) {
3201 remaining_words =
3202 (BCC(smb_buffer_response)
3203 - 1) / 2;
3204 bcc_ptr++; /* Unicode strings must be word aligned */
3205 } else {
3206 remaining_words = BCC(smb_buffer_response) / 2;
3207 }
Steve French77159b42007-08-31 01:10:17 +00003208 len = UniStrnlen((wchar_t *) bcc_ptr,
3209 remaining_words - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003210/* We look for obvious messed up bcc or strings in response so we do not go off
3211 the end since (at least) WIN2K and Windows XP have a major bug in not null
3212 terminating last Unicode string in response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003213 if (ses->serverOS)
Steve French08775832006-05-30 18:08:26 +00003214 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003216 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003218 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219 bcc_ptr, len,
3220 nls_codepage);
3221 bcc_ptr += 2 * (len + 1);
3222 remaining_words -= len + 1;
3223 ses->serverOS[2 * len] = 0;
3224 ses->serverOS[1 + (2 * len)] = 0;
3225 if (remaining_words > 0) {
3226 len = UniStrnlen((wchar_t *)
3227 bcc_ptr,
3228 remaining_words
3229 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00003230 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003232 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233 GFP_KERNEL);
3234 cifs_strfromUCS_le(ses->
3235 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003236 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 bcc_ptr,
3238 len,
3239 nls_codepage);
3240 bcc_ptr += 2 * (len + 1);
3241 ses->serverNOS[2 * len] = 0;
3242 ses->serverNOS[1+(2*len)] = 0;
3243 remaining_words -= len + 1;
3244 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00003245 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 /* last string not always null terminated (e.g. for Windows XP & 2000) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003247 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003248 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 {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003275 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003276 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003277 ses->serverDomain = kzalloc(2,GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00003278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 } else { /* no room so create dummy domain and NOS string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003280 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003281 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003282 ses->serverDomain = kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00003283 kfree(ses->serverNOS);
Pekka Enberge915fc42005-09-06 15:18:35 -07003284 ses->serverNOS = kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285 }
3286 } else { /* ASCII */
3287 len = strnlen(bcc_ptr, 1024);
Steve French50c2f752007-07-13 00:33:32 +00003288 if (((long) bcc_ptr + len) -
3289 (long) pByteArea(smb_buffer_response)
Steve French63135e02007-07-17 17:34:02 +00003290 <= BCC(smb_buffer_response)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003291 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00003292 kfree(ses->serverOS);
Steve French77159b42007-08-31 01:10:17 +00003293 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003294 strncpy(ses->serverOS,bcc_ptr, len);
3295
3296 bcc_ptr += len;
3297 bcc_ptr[0] = 0; /* null terminate the string */
3298 bcc_ptr++;
3299
3300 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00003301 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00003302 ses->serverNOS = kzalloc(len+1,
3303 GFP_KERNEL);
Steve French63135e02007-07-17 17:34:02 +00003304 strncpy(ses->serverNOS,
3305 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003306 bcc_ptr += len;
3307 bcc_ptr[0] = 0;
3308 bcc_ptr++;
3309
3310 len = strnlen(bcc_ptr, 1024);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003311 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003312 kfree(ses->serverDomain);
Steve French63135e02007-07-17 17:34:02 +00003313 ses->serverDomain =
3314 kzalloc(len+1,
3315 GFP_KERNEL);
3316 strncpy(ses->serverDomain,
3317 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003318 bcc_ptr += len;
3319 bcc_ptr[0] = 0;
3320 bcc_ptr++;
3321 } else
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003322 cFYI(1, ("field of length %d "
Steve French63135e02007-07-17 17:34:02 +00003323 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 len));
3325 }
3326 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003327 cERROR(1, ("Security Blob extends beyond end "
Steve French63135e02007-07-17 17:34:02 +00003328 "of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003329 }
3330 } else {
3331 cERROR(1, ("No session structure passed in."));
3332 }
3333 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003334 cERROR(1, ("Invalid Word count %d: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 smb_buffer_response->WordCount));
3336 rc = -EIO;
3337 }
3338
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003339 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340
3341 return rc;
3342}
3343
3344int
3345CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3346 const char *tree, struct cifsTconInfo *tcon,
3347 const struct nls_table *nls_codepage)
3348{
3349 struct smb_hdr *smb_buffer;
3350 struct smb_hdr *smb_buffer_response;
3351 TCONX_REQ *pSMB;
3352 TCONX_RSP *pSMBr;
3353 unsigned char *bcc_ptr;
3354 int rc = 0;
3355 int length;
3356 __u16 count;
3357
3358 if (ses == NULL)
3359 return -EIO;
3360
3361 smb_buffer = cifs_buf_get();
3362 if (smb_buffer == NULL) {
3363 return -ENOMEM;
3364 }
3365 smb_buffer_response = smb_buffer;
3366
3367 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3368 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003369
3370 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371 smb_buffer->Uid = ses->Suid;
3372 pSMB = (TCONX_REQ *) smb_buffer;
3373 pSMBr = (TCONX_RSP *) smb_buffer_response;
3374
3375 pSMB->AndXCommand = 0xFF;
3376 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003378 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08003379 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003380 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003381 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003382 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003383 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00003384 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003385 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3386 specified as required (when that support is added to
3387 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003388 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003389 by Samba (not sure whether other servers allow
3390 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003391#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French50c2f752007-07-13 00:33:32 +00003392 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
Steve French7c7b25b2006-06-01 19:20:10 +00003393 (ses->server->secType == LANMAN))
3394 calc_lanman_hash(ses, bcc_ptr);
3395 else
3396#endif /* CIFS_WEAK_PW_HASH */
Steve Frencheeac8042006-01-13 21:34:58 -08003397 SMBNTencrypt(ses->password,
3398 ses->server->cryptKey,
3399 bcc_ptr);
3400
Steve French7c7b25b2006-06-01 19:20:10 +00003401 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003402 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003403 /* must align unicode strings */
3404 *bcc_ptr = 0; /* null byte password */
3405 bcc_ptr++;
3406 }
Steve Frencheeac8042006-01-13 21:34:58 -08003407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408
Steve French50c2f752007-07-13 00:33:32 +00003409 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003410 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3412
3413 if (ses->capabilities & CAP_STATUS32) {
3414 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3415 }
3416 if (ses->capabilities & CAP_DFS) {
3417 smb_buffer->Flags2 |= SMBFLG2_DFS;
3418 }
3419 if (ses->capabilities & CAP_UNICODE) {
3420 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3421 length =
Steve French50c2f752007-07-13 00:33:32 +00003422 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3423 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003424 (/* server len*/ + 256 /* share len */), nls_codepage);
3425 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 bcc_ptr += 2; /* skip trailing null */
3427 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428 strcpy(bcc_ptr, tree);
3429 bcc_ptr += strlen(tree) + 1;
3430 }
3431 strcpy(bcc_ptr, "?????");
3432 bcc_ptr += strlen("?????");
3433 bcc_ptr += 1;
3434 count = bcc_ptr - &pSMB->Password[0];
3435 pSMB->hdr.smb_buf_length += count;
3436 pSMB->ByteCount = cpu_to_le16(count);
3437
Steve French133672e2007-11-13 22:41:37 +00003438 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3439 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440
3441 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3442 /* above now done in SendReceive */
3443 if ((rc == 0) && (tcon != NULL)) {
3444 tcon->tidStatus = CifsGood;
3445 tcon->tid = smb_buffer_response->Tid;
3446 bcc_ptr = pByteArea(smb_buffer_response);
3447 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3463 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3464 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3465 if ((bcc_ptr + (2 * length)) -
3466 pByteArea(smb_buffer_response) <=
3467 BCC(smb_buffer_response)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08003468 kfree(tcon->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469 tcon->nativeFileSystem =
Pekka Enberge915fc42005-09-06 15:18:35 -07003470 kzalloc(length + 2, GFP_KERNEL);
Steve French88f370a2007-09-15 03:01:17 +00003471 if (tcon->nativeFileSystem)
3472 cifs_strfromUCS_le(
3473 tcon->nativeFileSystem,
3474 (__le16 *) bcc_ptr,
3475 length, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003476 bcc_ptr += 2 * length;
3477 bcc_ptr[0] = 0; /* null terminate the string */
3478 bcc_ptr[1] = 0;
3479 bcc_ptr += 2;
3480 }
Steve French50c2f752007-07-13 00:33:32 +00003481 /* else do not bother copying these information fields*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482 } else {
3483 length = strnlen(bcc_ptr, 1024);
3484 if ((bcc_ptr + length) -
3485 pByteArea(smb_buffer_response) <=
3486 BCC(smb_buffer_response)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08003487 kfree(tcon->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 tcon->nativeFileSystem =
Pekka Enberge915fc42005-09-06 15:18:35 -07003489 kzalloc(length + 1, GFP_KERNEL);
Steve French88f370a2007-09-15 03:01:17 +00003490 if (tcon->nativeFileSystem)
3491 strncpy(tcon->nativeFileSystem, bcc_ptr,
3492 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 }
Steve French50c2f752007-07-13 00:33:32 +00003494 /* else do not bother copying these information fields*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003496 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003497 (smb_buffer_response->WordCount == 7))
3498 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003499 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3500 else
3501 tcon->Flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3503 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003504 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 ses->ipc_tid = smb_buffer_response->Tid;
3506 }
3507
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003508 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 return rc;
3510}
3511
3512int
3513cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3514{
3515 int rc = 0;
3516 int xid;
3517 struct cifsSesInfo *ses = NULL;
3518 struct task_struct *cifsd_task;
Steve French50c2f752007-07-13 00:33:32 +00003519 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520
3521 xid = GetXid();
3522
3523 if (cifs_sb->tcon) {
3524 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3525 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3526 if (rc == -EBUSY) {
3527 FreeXid(xid);
3528 return 0;
3529 }
Steve French5d941ca2008-04-15 18:40:48 +00003530 DeleteTconOplockQEntries(cifs_sb->tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003531 tconInfoFree(cifs_sb->tcon);
3532 if ((ses) && (ses->server)) {
3533 /* save off task so we do not refer to ses later */
3534 cifsd_task = ses->server->tsk;
3535 cFYI(1, ("About to do SMBLogoff "));
3536 rc = CIFSSMBLogoff(xid, ses);
3537 if (rc == -EBUSY) {
3538 FreeXid(xid);
3539 return 0;
3540 } else if (rc == -ESHUTDOWN) {
Steve French467a8f82007-06-27 22:41:32 +00003541 cFYI(1, ("Waking up socket by sending signal"));
Steve Frenchf7f7c312007-05-24 02:29:51 +00003542 if (cifsd_task) {
Steve French50c2f752007-07-13 00:33:32 +00003543 force_sig(SIGKILL, cifsd_task);
Igor Mammedovaaf737a2007-04-03 19:16:43 +00003544 kthread_stop(cifsd_task);
Steve Frenchf1914012005-08-18 09:37:34 -07003545 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 rc = 0;
3547 } /* else - we have an smb session
3548 left on this socket do not kill cifsd */
3549 } else
3550 cFYI(1, ("No session or bad tcon"));
3551 }
Steve French50c2f752007-07-13 00:33:32 +00003552
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553 cifs_sb->tcon = NULL;
Steve French2fe87f02006-09-21 07:02:52 +00003554 tmp = cifs_sb->prepath;
3555 cifs_sb->prepathlen = 0;
3556 cifs_sb->prepath = NULL;
3557 kfree(tmp);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -07003558 if (ses)
3559 schedule_timeout_interruptible(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003560 if (ses)
3561 sesInfoFree(ses);
3562
3563 FreeXid(xid);
Steve French88e7d702008-01-03 17:37:09 +00003564 return rc;
Steve French50c2f752007-07-13 00:33:32 +00003565}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566
3567int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
Steve French50c2f752007-07-13 00:33:32 +00003568 struct nls_table *nls_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003569{
3570 int rc = 0;
Steve French7c7b25b2006-06-01 19:20:10 +00003571 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572 int ntlmv2_flag = FALSE;
Steve Frenchad009ac2005-04-28 22:41:05 -07003573 int first_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574
3575 /* what if server changes its buffer size after dropping the session? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003576 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003578 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve French50c2f752007-07-13 00:33:32 +00003580 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581 rc = -EHOSTDOWN;
3582 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003583 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003585 if (pSesInfo->server->tcpStatus != CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586 pSesInfo->server->tcpStatus = CifsGood;
3587 else
3588 rc = -EHOSTDOWN;
3589 spin_unlock(&GlobalMid_Lock);
3590
3591 }
Steve Frenchad009ac2005-04-28 22:41:05 -07003592 first_time = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 }
3594 if (!rc) {
Steve French9ac00b72006-09-30 04:13:17 +00003595 pSesInfo->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 pSesInfo->capabilities = pSesInfo->server->capabilities;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003597 if (linuxExtEnabled == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003598 pSesInfo->capabilities &= (~CAP_UNIX);
Steve Frenchad009ac2005-04-28 22:41:05 -07003599 /* pSesInfo->sequence_number = 0;*/
Steve French50c2f752007-07-13 00:33:32 +00003600 cFYI(1,
3601 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003602 pSesInfo->server->secMode,
3603 pSesInfo->server->capabilities,
Steve French175ec9e2006-09-30 01:07:38 +00003604 pSesInfo->server->timeAdj));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003605 if (experimEnabled < 2)
Steve French39798772006-05-31 22:40:51 +00003606 rc = CIFS_SessSetup(xid, pSesInfo,
3607 first_time, nls_info);
Steve French189acaa2006-06-23 02:33:48 +00003608 else if (extended_security
Steve French50c2f752007-07-13 00:33:32 +00003609 && (pSesInfo->capabilities
Steve French175ec9e2006-09-30 01:07:38 +00003610 & CAP_EXTENDED_SECURITY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003611 && (pSesInfo->server->secType == NTLMSSP)) {
Steve French189acaa2006-06-23 02:33:48 +00003612 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003613 } else if (extended_security
3614 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3615 && (pSesInfo->server->secType == RawNTLMSSP)) {
Steve French5815449d2006-02-14 01:36:20 +00003616 cFYI(1, ("NTLMSSP sesssetup"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003617 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3618 pSesInfo,
3619 &ntlmv2_flag,
3620 nls_info);
3621 if (!rc) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003622 if (ntlmv2_flag) {
Steve French50c2f752007-07-13 00:33:32 +00003623 char *v2_response;
Steve French467a8f82007-06-27 22:41:32 +00003624 cFYI(1, ("more secure NTLM ver2 hash"));
Steve French50c2f752007-07-13 00:33:32 +00003625 if (CalcNTLMv2_partial_mac_key(pSesInfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626 nls_info)) {
3627 rc = -ENOMEM;
3628 goto ss_err_exit;
3629 } else
3630 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003631 if (v2_response) {
Steve French50c2f752007-07-13 00:33:32 +00003632 CalcNTLMv2_response(pSesInfo,
3633 v2_response);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003634 /* if (first_time)
Steve French50c2f752007-07-13 00:33:32 +00003635 cifs_calculate_ntlmv2_mac_key(
3636 pSesInfo->server->mac_signing_key,
3637 response, ntlm_session_key,*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003638 kfree(v2_response);
3639 /* BB Put dummy sig in SessSetup PDU? */
3640 } else {
3641 rc = -ENOMEM;
3642 goto ss_err_exit;
3643 }
3644
3645 } else {
3646 SMBNTencrypt(pSesInfo->password,
3647 pSesInfo->server->cryptKey,
3648 ntlm_session_key);
3649
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003650 if (first_time)
Steve Frenchad009ac2005-04-28 22:41:05 -07003651 cifs_calculate_mac_key(
Steve Frenchb609f062007-07-09 07:55:14 +00003652 &pSesInfo->server->mac_signing_key,
Steve Frenchad009ac2005-04-28 22:41:05 -07003653 ntlm_session_key,
3654 pSesInfo->password);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003655 }
3656 /* for better security the weaker lanman hash not sent
3657 in AuthSessSetup so we no longer calculate it */
3658
3659 rc = CIFSNTLMSSPAuthSessSetup(xid,
3660 pSesInfo,
3661 ntlm_session_key,
3662 ntlmv2_flag,
3663 nls_info);
3664 }
3665 } else { /* old style NTLM 0.12 session setup */
3666 SMBNTencrypt(pSesInfo->password,
3667 pSesInfo->server->cryptKey,
3668 ntlm_session_key);
3669
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003670 if (first_time)
Steve Frenchad009ac2005-04-28 22:41:05 -07003671 cifs_calculate_mac_key(
Steve Frenchb609f062007-07-09 07:55:14 +00003672 &pSesInfo->server->mac_signing_key,
Steve Frenchad009ac2005-04-28 22:41:05 -07003673 ntlm_session_key, pSesInfo->password);
3674
Linus Torvalds1da177e2005-04-16 15:20:36 -07003675 rc = CIFSSessSetup(xid, pSesInfo,
3676 ntlm_session_key, nls_info);
3677 }
3678 if (rc) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003679 cERROR(1, ("Send error in SessSetup = %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003680 } else {
Steve French467a8f82007-06-27 22:41:32 +00003681 cFYI(1, ("CIFS Session Established successfully"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003682 pSesInfo->status = CifsGood;
3683 }
3684 }
3685ss_err_exit:
3686 return rc;
3687}
3688