blob: c4b32b7f4355e4c2a56c35134457abf501c98212 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve French75865f8c2007-06-24 18:30:48 +00004 * Copyright (C) International Business Machines Corp., 2002,2007
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;
Steve French46810cb2005-04-28 22:41:09 -0700441 } else if (length < 4) {
Steve Frenchf01d5e12007-08-30 21:13:31 +0000442 cFYI(1, ("less than four bytes received (%d bytes)",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 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{
1413 unsigned char *referrals = NULL;
1414 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,
1432 unsigned char **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433{
1434 char *temp_unc;
1435 int rc = 0;
1436
1437 *pnum_referrals = 0;
1438
1439 if (pSesInfo->ipc_tid == 0) {
1440 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00001441 strnlen(pSesInfo->serverName,
1442 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 + 1 + 4 /* slash IPC$ */ + 2,
1444 GFP_KERNEL);
1445 if (temp_unc == NULL)
1446 return -ENOMEM;
1447 temp_unc[0] = '\\';
1448 temp_unc[1] = '\\';
1449 strcpy(temp_unc + 2, pSesInfo->serverName);
1450 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1451 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1452 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00001453 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 kfree(temp_unc);
1455 }
1456 if (rc == 0)
1457 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07001458 pnum_referrals, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460 return rc;
1461}
1462
1463/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00001464static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465{
Steve French50c2f752007-07-13 00:33:32 +00001466 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467
Steve French50c2f752007-07-13 00:33:32 +00001468 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 /* mask a nibble at a time and encode */
1470 target[j] = 'A' + (0x0F & (source[i] >> 4));
1471 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00001472 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 }
1474
1475}
1476
1477
1478static int
Steve French50c2f752007-07-13 00:33:32 +00001479ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1480 char *netbios_name, char *target_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481{
1482 int rc = 0;
1483 int connected = 0;
1484 __be16 orig_port = 0;
1485
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001486 if (*csocket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001487 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1488 IPPROTO_TCP, csocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001490 cERROR(1, ("Error %d creating socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 *csocket = NULL;
1492 return rc;
1493 } else {
1494 /* BB other socket options to set KEEPALIVE, NODELAY? */
Steve French467a8f82007-06-27 22:41:32 +00001495 cFYI(1, ("Socket created"));
Steve French50c2f752007-07-13 00:33:32 +00001496 (*csocket)->sk->sk_allocation = GFP_NOFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 }
1498 }
1499
1500 psin_server->sin_family = AF_INET;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001501 if (psin_server->sin_port) { /* user overrode default port */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 rc = (*csocket)->ops->connect(*csocket,
1503 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001504 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 if (rc >= 0)
1506 connected = 1;
Steve French50c2f752007-07-13 00:33:32 +00001507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001509 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001510 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 later if fall back ports fail this time */
1512 orig_port = psin_server->sin_port;
1513
1514 /* do not retry on the same port we just failed on */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001515 if (psin_server->sin_port != htons(CIFS_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 psin_server->sin_port = htons(CIFS_PORT);
1517
1518 rc = (*csocket)->ops->connect(*csocket,
1519 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001520 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 if (rc >= 0)
1522 connected = 1;
1523 }
1524 }
1525 if (!connected) {
1526 psin_server->sin_port = htons(RFC1001_PORT);
1527 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
Steve French50c2f752007-07-13 00:33:32 +00001528 psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001529 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00001530 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 connected = 1;
1532 }
1533
1534 /* give up here - unless we want to retry on different
1535 protocol families some day */
1536 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001537 if (orig_port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 psin_server->sin_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001539 cFYI(1, ("Error %d connecting to server via ipv4", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 sock_release(*csocket);
1541 *csocket = NULL;
1542 return rc;
1543 }
Steve French50c2f752007-07-13 00:33:32 +00001544 /* Eventually check for other socket options to change from
1545 the default. sock_setsockopt not used because it expects
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 user space buffer */
Steve French50c2f752007-07-13 00:33:32 +00001547 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1548 (*csocket)->sk->sk_sndbuf,
Steve Frenchb387eae2005-10-10 14:21:15 -07001549 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchb387eae2005-10-10 14:21:15 -07001551 /* make the bufsizes depend on wsize/rsize and max requests */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001552 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
Steve Frenchb387eae2005-10-10 14:21:15 -07001553 (*csocket)->sk->sk_sndbuf = 200 * 1024;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001554 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
Steve Frenchb387eae2005-10-10 14:21:15 -07001555 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556
1557 /* send RFC1001 sessinit */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001558 if (psin_server->sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00001560 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00001562 struct rfc1002_session_packet *ses_init_buf;
1563 struct smb_hdr *smb_buf;
1564 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1565 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001566 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 ses_init_buf->trailer.session_req.called_len = 32;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001568 if (target_name && (target_name[0] != 0)) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001569 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1570 target_name, 16);
1571 } else {
1572 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
Steve French50c2f752007-07-13 00:33:32 +00001573 DEFAULT_CIFS_CALLED_NAME, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001574 }
1575
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 ses_init_buf->trailer.session_req.calling_len = 32;
1577 /* calling name ends in null (byte 16) from old smb
1578 convention. */
Steve French50c2f752007-07-13 00:33:32 +00001579 if (netbios_name && (netbios_name[0] != 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
Steve French50c2f752007-07-13 00:33:32 +00001581 netbios_name, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 } else {
1583 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
Steve French50c2f752007-07-13 00:33:32 +00001584 "LINUX_CIFS_CLNT", 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 }
1586 ses_init_buf->trailer.session_req.scope1 = 0;
1587 ses_init_buf->trailer.session_req.scope2 = 0;
1588 smb_buf = (struct smb_hdr *)ses_init_buf;
1589 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1590 smb_buf->smb_buf_length = 0x81000044;
1591 rc = smb_send(*csocket, smb_buf, 0x44,
1592 (struct sockaddr *)psin_server);
1593 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00001594 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00001595 requires very short break before negprot
1596 presumably because not expecting negprot
1597 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00001598 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00001599 complicating the code and causes no
1600 significant slowing down on mount
1601 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 }
Steve French50c2f752007-07-13 00:33:32 +00001603 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00001605
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 }
Steve French50c2f752007-07-13 00:33:32 +00001607
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 return rc;
1609}
1610
1611static int
1612ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1613{
1614 int rc = 0;
1615 int connected = 0;
1616 __be16 orig_port = 0;
1617
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001618 if (*csocket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001619 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1620 IPPROTO_TCP, csocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001622 cERROR(1, ("Error %d creating ipv6 socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 *csocket = NULL;
1624 return rc;
1625 } else {
1626 /* BB other socket options to set KEEPALIVE, NODELAY? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001627 cFYI(1, ("ipv6 Socket created"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 (*csocket)->sk->sk_allocation = GFP_NOFS;
1629 }
1630 }
1631
1632 psin_server->sin6_family = AF_INET6;
1633
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001634 if (psin_server->sin6_port) { /* user overrode default port */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 rc = (*csocket)->ops->connect(*csocket,
1636 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001637 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 if (rc >= 0)
1639 connected = 1;
Steve French50c2f752007-07-13 00:33:32 +00001640 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001642 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001643 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 later if fall back ports fail this time */
1645
1646 orig_port = psin_server->sin6_port;
1647 /* do not retry on the same port we just failed on */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001648 if (psin_server->sin6_port != htons(CIFS_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 psin_server->sin6_port = htons(CIFS_PORT);
1650
1651 rc = (*csocket)->ops->connect(*csocket,
1652 (struct sockaddr *) psin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001653 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 if (rc >= 0)
1655 connected = 1;
1656 }
1657 }
1658 if (!connected) {
1659 psin_server->sin6_port = htons(RFC1001_PORT);
1660 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001661 psin_server, sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00001662 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 connected = 1;
1664 }
1665
1666 /* give up here - unless we want to retry on different
1667 protocol families some day */
1668 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001669 if (orig_port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 psin_server->sin6_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001671 cFYI(1, ("Error %d connecting to server via ipv6", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 sock_release(*csocket);
1673 *csocket = NULL;
1674 return rc;
1675 }
Steve French50c2f752007-07-13 00:33:32 +00001676 /* Eventually check for other socket options to change from
1677 the default. sock_setsockopt not used because it expects
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 user space buffer */
1679 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
Steve French50c2f752007-07-13 00:33:32 +00001680
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return rc;
1682}
1683
Steve French50c2f752007-07-13 00:33:32 +00001684void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1685 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00001686{
1687 /* if we are reconnecting then should we check to see if
1688 * any requested capabilities changed locally e.g. via
1689 * remount but we can not do much about it here
1690 * if they have (even if we could detect it by the following)
1691 * Perhaps we could add a backpointer to array of sb from tcon
1692 * or if we change to make all sb to same share the same
1693 * sb as NFS - then we only have one backpointer to sb.
1694 * What if we wanted to mount the server share twice once with
1695 * and once without posixacls or posix paths? */
1696 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001697
Steve Frenchc18c8422007-07-18 23:21:09 +00001698 if (vol_info && vol_info->no_linux_ext) {
1699 tcon->fsUnixInfo.Capability = 0;
1700 tcon->unix_ext = 0; /* Unix Extensions disabled */
1701 cFYI(1, ("Linux protocol extensions disabled"));
1702 return;
1703 } else if (vol_info)
1704 tcon->unix_ext = 1; /* Unix Extensions supported */
1705
1706 if (tcon->unix_ext == 0) {
1707 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1708 return;
1709 }
Steve French50c2f752007-07-13 00:33:32 +00001710
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001711 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00001712 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001713
Steve French8af18972007-02-14 04:42:51 +00001714 /* check for reconnect case in which we do not
1715 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001716 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001717 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00001718 originally at mount time */
1719 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1720 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1721 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
1722 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French8af18972007-02-14 04:42:51 +00001723 }
Steve French50c2f752007-07-13 00:33:32 +00001724
Steve French8af18972007-02-14 04:42:51 +00001725 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00001726 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00001727 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00001728 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001729 cFYI(1, ("negotiated posix acl support"));
1730 if (sb)
Steve French8af18972007-02-14 04:42:51 +00001731 sb->s_flags |= MS_POSIXACL;
1732 }
1733
Steve French75865f8c2007-06-24 18:30:48 +00001734 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00001735 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00001736 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001737 cFYI(1, ("negotiate posix pathnames"));
Steve French75865f8c2007-06-24 18:30:48 +00001738 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00001739 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00001740 CIFS_MOUNT_POSIX_PATHS;
1741 }
Steve French50c2f752007-07-13 00:33:32 +00001742
Steve French984acfe2007-04-26 16:42:50 +00001743 /* We might be setting the path sep back to a different
1744 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00001745 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00001746 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00001747 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00001748
1749 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1750 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1751 CIFS_SB(sb)->rsize = 127 * 1024;
1752#ifdef CONFIG_CIFS_DEBUG2
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001753 cFYI(1, ("larger reads not supported by srv"));
Steve French75865f8c2007-06-24 18:30:48 +00001754#endif
1755 }
1756 }
Steve French50c2f752007-07-13 00:33:32 +00001757
1758
1759 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
Steve French8af18972007-02-14 04:42:51 +00001760#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00001761 if (cap & CIFS_UNIX_FCNTL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001762 cFYI(1, ("FCNTL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001763 if (cap & CIFS_UNIX_EXTATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001764 cFYI(1, ("EXTATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001765 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001766 cFYI(1, ("POSIX path cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001767 if (cap & CIFS_UNIX_XATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001768 cFYI(1, ("XATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001769 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001770 cFYI(1, ("POSIX ACL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001771 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001772 cFYI(1, ("very large read cap"));
Steve French75865f8c2007-06-24 18:30:48 +00001773 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001774 cFYI(1, ("very large write cap"));
Steve French8af18972007-02-14 04:42:51 +00001775#endif /* CIFS_DEBUG2 */
1776 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00001777 if (vol_info == NULL) {
Steve French5a44b312007-09-20 15:16:24 +00001778 cFYI(1, ("resetting capabilities failed"));
Steve French442aa312007-09-24 20:25:46 +00001779 } else
Steve French5a44b312007-09-20 15:16:24 +00001780 cERROR(1, ("Negotiating Unix capabilities "
1781 "with the server failed. Consider "
1782 "mounting with the Unix Extensions\n"
1783 "disabled, if problems are found, "
1784 "by specifying the nounix mount "
Steve French2224f4e2007-09-20 15:37:29 +00001785 "option."));
Steve French5a44b312007-09-20 15:16:24 +00001786
Steve French8af18972007-02-14 04:42:51 +00001787 }
1788 }
1789}
1790
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791int
1792cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1793 char *mount_data, const char *devname)
1794{
1795 int rc = 0;
1796 int xid;
1797 int address_type = AF_INET;
1798 struct socket *csocket = NULL;
1799 struct sockaddr_in sin_server;
1800 struct sockaddr_in6 sin_server6;
1801 struct smb_vol volume_info;
1802 struct cifsSesInfo *pSesInfo = NULL;
1803 struct cifsSesInfo *existingCifsSes = NULL;
1804 struct cifsTconInfo *tcon = NULL;
1805 struct TCP_Server_Info *srvTcp = NULL;
1806
1807 xid = GetXid();
1808
1809/* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
Steve French50c2f752007-07-13 00:33:32 +00001810
1811 memset(&volume_info, 0, sizeof(struct smb_vol));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001813 rc = -EINVAL;
1814 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 }
1816
Jeff Layton8426c392007-05-05 03:27:49 +00001817 if (volume_info.nullauth) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001818 cFYI(1, ("null user"));
Jeff Layton9b8f5f52007-11-09 23:25:04 +00001819 volume_info.username = "";
Jeff Layton8426c392007-05-05 03:27:49 +00001820 } else if (volume_info.username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 /* BB fixme parse for domain name here */
Steve French467a8f82007-06-27 22:41:32 +00001822 cFYI(1, ("Username: %s", volume_info.username));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08001824 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00001825 /* In userspace mount helper we can get user name from alternate
1826 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001827 rc = -EINVAL;
1828 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 }
1830
1831 if (volume_info.UNCip && volume_info.UNC) {
Steve French50c2f752007-07-13 00:33:32 +00001832 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1833 &sin_server.sin_addr.s_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001835 if (rc <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 /* not ipv4 address, try ipv6 */
Steve French50c2f752007-07-13 00:33:32 +00001837 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1838 &sin_server6.sin6_addr.in6_u);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001839 if (rc > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 address_type = AF_INET6;
1841 } else {
1842 address_type = AF_INET;
1843 }
Steve French50c2f752007-07-13 00:33:32 +00001844
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001845 if (rc <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 /* we failed translating address */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001847 rc = -EINVAL;
1848 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 }
1850
1851 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1852 /* success */
1853 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001854 } else if (volume_info.UNCip) {
1855 /* BB using ip addr as server name to connect to the
1856 DFS root below */
1857 cERROR(1, ("Connecting to DFS root not implemented yet"));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001858 rc = -EINVAL;
1859 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 } else /* which servers DFS root would we conect to */ {
1861 cERROR(1,
Steve French50c2f752007-07-13 00:33:32 +00001862 ("CIFS mount error: No UNC path (e.g. -o "
1863 "unc=//192.168.1.100/public) specified"));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001864 rc = -EINVAL;
1865 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 }
1867
1868 /* this is needed for ASCII cp to Unicode converts */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001869 if (volume_info.iocharset == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 cifs_sb->local_nls = load_nls_default();
1871 /* load_nls_default can not return null */
1872 } else {
1873 cifs_sb->local_nls = load_nls(volume_info.iocharset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001874 if (cifs_sb->local_nls == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001875 cERROR(1, ("CIFS mount error: iocharset %s not found",
1876 volume_info.iocharset));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001877 rc = -ELIBACC;
1878 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 }
1880 }
1881
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001882 if (address_type == AF_INET)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1884 NULL /* no ipv6 addr */,
1885 volume_info.username, &srvTcp);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001886 else if (address_type == AF_INET6) {
1887 cFYI(1, ("looking for ipv6 address"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1889 &sin_server6.sin6_addr,
1890 volume_info.username, &srvTcp);
Steve French5858ae42007-04-25 11:59:10 +00001891 } else {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001892 rc = -EINVAL;
1893 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 }
1895
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 if (srvTcp) {
Steve French50c2f752007-07-13 00:33:32 +00001897 cFYI(1, ("Existing tcp session with server found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 } else { /* create socket */
Steve French4523cc32007-04-30 20:13:06 +00001899 if (volume_info.port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 sin_server.sin_port = htons(volume_info.port);
1901 else
1902 sin_server.sin_port = 0;
Steve French5858ae42007-04-25 11:59:10 +00001903 if (address_type == AF_INET6) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001904 cFYI(1, ("attempting ipv6 connect"));
Steve French5858ae42007-04-25 11:59:10 +00001905 /* BB should we allow ipv6 on port 139? */
1906 /* other OS never observed in Wild doing 139 with v6 */
Steve French50c2f752007-07-13 00:33:32 +00001907 rc = ipv6_connect(&sin_server6, &csocket);
1908 } else
1909 rc = ipv4_connect(&sin_server, &csocket,
Steve Frencha10faeb22005-08-22 21:38:31 -07001910 volume_info.source_rfc1001_name,
1911 volume_info.target_rfc1001_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001913 cERROR(1, ("Error connecting to IPv4 socket. "
1914 "Aborting operation"));
Steve French4523cc32007-04-30 20:13:06 +00001915 if (csocket != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 sock_release(csocket);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001917 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 }
1919
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00001920 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1921 if (!srvTcp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 rc = -ENOMEM;
1923 sock_release(csocket);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001924 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 } else {
Steve French50c2f752007-07-13 00:33:32 +00001926 memcpy(&srvTcp->addr.sockAddr, &sin_server,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001927 sizeof(struct sockaddr_in));
Steve French50c2f752007-07-13 00:33:32 +00001928 atomic_set(&srvTcp->inFlight, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 /* BB Add code for ipv6 case too */
1930 srvTcp->ssocket = csocket;
1931 srvTcp->protocolType = IPV4;
Jeff Laytonc359cf32007-11-16 22:22:06 +00001932 srvTcp->hostname = extract_hostname(volume_info.UNC);
1933 if (IS_ERR(srvTcp->hostname)) {
1934 rc = PTR_ERR(srvTcp->hostname);
1935 sock_release(csocket);
1936 goto out;
1937 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 init_waitqueue_head(&srvTcp->response_q);
1939 init_waitqueue_head(&srvTcp->request_q);
1940 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1941 /* at this point we are the only ones with the pointer
1942 to the struct since the kernel thread not created yet
1943 so no need to spinlock this init of tcpStatus */
1944 srvTcp->tcpStatus = CifsNew;
1945 init_MUTEX(&srvTcp->tcpSem);
Igor Mammedovaaf737a2007-04-03 19:16:43 +00001946 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
Steve French8840dee2007-11-16 23:05:52 +00001947 if (IS_ERR(srvTcp->tsk)) {
Igor Mammedovaaf737a2007-04-03 19:16:43 +00001948 rc = PTR_ERR(srvTcp->tsk);
Steve French50c2f752007-07-13 00:33:32 +00001949 cERROR(1, ("error %d create cifsd thread", rc));
Igor Mammedovaaf737a2007-04-03 19:16:43 +00001950 srvTcp->tsk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 sock_release(csocket);
Jeff Laytonc359cf32007-11-16 22:22:06 +00001952 kfree(srvTcp->hostname);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001953 goto out;
Steve Frenchf1914012005-08-18 09:37:34 -07001954 }
1955 wait_for_completion(&cifsd_complete);
1956 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001957 memcpy(srvTcp->workstation_RFC1001_name,
1958 volume_info.source_rfc1001_name, 16);
1959 memcpy(srvTcp->server_RFC1001_name,
1960 volume_info.target_rfc1001_name, 16);
Steve Frenchad009ac2005-04-28 22:41:05 -07001961 srvTcp->sequence_number = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 }
1963 }
1964
1965 if (existingCifsSes) {
1966 pSesInfo = existingCifsSes;
Steve Frenchbf820672005-12-01 22:32:42 -08001967 cFYI(1, ("Existing smb sess found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 } else if (!rc) {
Steve Frenchbf820672005-12-01 22:32:42 -08001969 cFYI(1, ("Existing smb sess not found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 pSesInfo = sesInfoAlloc();
1971 if (pSesInfo == NULL)
1972 rc = -ENOMEM;
1973 else {
1974 pSesInfo->server = srvTcp;
1975 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
1976 NIPQUAD(sin_server.sin_addr.s_addr));
1977 }
1978
Steve French50c2f752007-07-13 00:33:32 +00001979 if (!rc) {
1980 /* volume_info.password freed at unmount */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001981 if (volume_info.password) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 pSesInfo->password = volume_info.password;
Jeff Layton70fe7dc2007-11-16 22:21:07 +00001983 /* set to NULL to prevent freeing on exit */
1984 volume_info.password = NULL;
1985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 if (volume_info.username)
1987 strncpy(pSesInfo->userName,
Steve French50c2f752007-07-13 00:33:32 +00001988 volume_info.username,
1989 MAX_USERNAME_SIZE);
Steve French39798772006-05-31 22:40:51 +00001990 if (volume_info.domainname) {
1991 int len = strlen(volume_info.domainname);
Steve French50c2f752007-07-13 00:33:32 +00001992 pSesInfo->domainName =
Steve French39798772006-05-31 22:40:51 +00001993 kmalloc(len + 1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001994 if (pSesInfo->domainName)
Steve French39798772006-05-31 22:40:51 +00001995 strcpy(pSesInfo->domainName,
1996 volume_info.domainname);
1997 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 pSesInfo->linux_uid = volume_info.linux_uid;
Steve French750d1152006-06-27 06:28:30 +00001999 pSesInfo->overrideSecFlg = volume_info.secFlg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 down(&pSesInfo->sesSem);
Steve French189acaa2006-06-23 02:33:48 +00002001 /* BB FIXME need to pass vol->secFlgs BB */
Steve French50c2f752007-07-13 00:33:32 +00002002 rc = cifs_setup_session(xid, pSesInfo,
2003 cifs_sb->local_nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 up(&pSesInfo->sesSem);
Steve French4523cc32007-04-30 20:13:06 +00002005 if (!rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 atomic_inc(&srvTcp->socketUseCount);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002007 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 }
Steve French50c2f752007-07-13 00:33:32 +00002009
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 /* search for existing tcon to this server share */
2011 if (!rc) {
Steve French4523cc32007-04-30 20:13:06 +00002012 if (volume_info.rsize > CIFSMaxBufSize) {
Steve French50c2f752007-07-13 00:33:32 +00002013 cERROR(1, ("rsize %d too large, using MaxBufSize",
Steve French0ae0efa2005-10-10 10:57:19 -07002014 volume_info.rsize));
2015 cifs_sb->rsize = CIFSMaxBufSize;
Steve French75865f8c2007-06-24 18:30:48 +00002016 } else if ((volume_info.rsize) &&
2017 (volume_info.rsize <= CIFSMaxBufSize))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 cifs_sb->rsize = volume_info.rsize;
Steve French0ae0efa2005-10-10 10:57:19 -07002019 else /* default */
2020 cifs_sb->rsize = CIFSMaxBufSize;
2021
Steve French4523cc32007-04-30 20:13:06 +00002022 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
Steve French50c2f752007-07-13 00:33:32 +00002023 cERROR(1, ("wsize %d too large, using 4096 instead",
Steve French0ae0efa2005-10-10 10:57:19 -07002024 volume_info.wsize));
2025 cifs_sb->wsize = 4096;
Steve French4523cc32007-04-30 20:13:06 +00002026 } else if (volume_info.wsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 cifs_sb->wsize = volume_info.wsize;
2028 else
Steve French50c2f752007-07-13 00:33:32 +00002029 cifs_sb->wsize =
Steve French1877c9e2006-01-27 18:36:11 -08002030 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2031 127*1024);
Steve French17cbbaf2006-01-24 20:26:48 -08002032 /* old default of CIFSMaxBufSize was too small now
Steve French50c2f752007-07-13 00:33:32 +00002033 that SMB Write2 can send multiple pages in kvec.
Steve French17cbbaf2006-01-24 20:26:48 -08002034 RFC1001 does not describe what happens when frame
2035 bigger than 128K is sent so use that as max in
2036 conjunction with 52K kvec constraint on arch with 4K
2037 page size */
2038
Steve French4523cc32007-04-30 20:13:06 +00002039 if (cifs_sb->rsize < 2048) {
Steve French50c2f752007-07-13 00:33:32 +00002040 cifs_sb->rsize = 2048;
Steve French6cec2ae2006-02-22 17:31:52 -06002041 /* Windows ME may prefer this */
Steve French467a8f82007-06-27 22:41:32 +00002042 cFYI(1, ("readsize set to minimum: 2048"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 }
Steve French2fe87f02006-09-21 07:02:52 +00002044 /* calculate prepath */
2045 cifs_sb->prepath = volume_info.prepath;
Steve French4523cc32007-04-30 20:13:06 +00002046 if (cifs_sb->prepath) {
Steve French2fe87f02006-09-21 07:02:52 +00002047 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2048 cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
2049 volume_info.prepath = NULL;
Steve French50c2f752007-07-13 00:33:32 +00002050 } else
Steve French2fe87f02006-09-21 07:02:52 +00002051 cifs_sb->prepathlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 cifs_sb->mnt_uid = volume_info.linux_uid;
2053 cifs_sb->mnt_gid = volume_info.linux_gid;
2054 cifs_sb->mnt_file_mode = volume_info.file_mode;
2055 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
Steve French467a8f82007-06-27 22:41:32 +00002056 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2057 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058
Steve French4523cc32007-04-30 20:13:06 +00002059 if (volume_info.noperm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
Steve French4523cc32007-04-30 20:13:06 +00002061 if (volume_info.setuids)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
Steve French4523cc32007-04-30 20:13:06 +00002063 if (volume_info.server_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
Steve French4523cc32007-04-30 20:13:06 +00002065 if (volume_info.remap)
Steve French6a0b4822005-04-28 22:41:05 -07002066 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
Steve French4523cc32007-04-30 20:13:06 +00002067 if (volume_info.no_xattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
Steve French4523cc32007-04-30 20:13:06 +00002069 if (volume_info.sfu_emul)
Steve Frenchd7245c22005-07-14 18:25:12 -05002070 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
Steve French4523cc32007-04-30 20:13:06 +00002071 if (volume_info.nobrl)
Steve Frenchc46fa8a2005-08-18 20:49:57 -07002072 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve French4523cc32007-04-30 20:13:06 +00002073 if (volume_info.cifs_acl)
Steve French0a4b92c2006-01-12 15:44:21 -08002074 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Steve French4523cc32007-04-30 20:13:06 +00002075 if (volume_info.override_uid)
2076 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2077 if (volume_info.override_gid)
2078 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2079 if (volume_info.direct_io) {
Steve French467a8f82007-06-27 22:41:32 +00002080 cFYI(1, ("mounting share using direct i/o"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2082 }
2083
2084 tcon =
2085 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2086 volume_info.username);
2087 if (tcon) {
Steve Frenchbf820672005-12-01 22:32:42 -08002088 cFYI(1, ("Found match on UNC path"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 /* we can have only one retry value for a connection
2090 to a share so for resources mounted more than once
Steve French50c2f752007-07-13 00:33:32 +00002091 to the same server share the last value passed in
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 for the retry flag is used */
2093 tcon->retry = volume_info.retry;
Steve Frenchd3485d32005-08-19 11:04:29 -07002094 tcon->nocase = volume_info.nocase;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 } else {
2096 tcon = tconInfoAlloc();
2097 if (tcon == NULL)
2098 rc = -ENOMEM;
2099 else {
Steve French50c2f752007-07-13 00:33:32 +00002100 /* check for null share name ie connecting to
Steve French8af18972007-02-14 04:42:51 +00002101 * dfs root */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102
Steve French50c2f752007-07-13 00:33:32 +00002103 /* BB check if this works for exactly length
Steve French8af18972007-02-14 04:42:51 +00002104 * three strings */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2106 && (strchr(volume_info.UNC + 3, '/') ==
2107 NULL)) {
Steve French737b7582005-04-28 22:41:06 -07002108 rc = connect_to_dfs_path(xid, pSesInfo,
Steve French8af18972007-02-14 04:42:51 +00002109 "", cifs_sb->local_nls,
Steve French50c2f752007-07-13 00:33:32 +00002110 cifs_sb->mnt_cifs_flags &
Steve French8af18972007-02-14 04:42:51 +00002111 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002112 rc = -ENODEV;
2113 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 } else {
Steve French8af18972007-02-14 04:42:51 +00002115 /* BB Do we need to wrap sesSem around
2116 * this TCon call and Unix SetFS as
2117 * we do on SessSetup and reconnect? */
Steve French50c2f752007-07-13 00:33:32 +00002118 rc = CIFSTCon(xid, pSesInfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 volume_info.UNC,
2120 tcon, cifs_sb->local_nls);
2121 cFYI(1, ("CIFS Tcon rc = %d", rc));
2122 }
2123 if (!rc) {
2124 atomic_inc(&pSesInfo->inUse);
2125 tcon->retry = volume_info.retry;
Steve Frenchd3485d32005-08-19 11:04:29 -07002126 tcon->nocase = volume_info.nocase;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 }
2128 }
2129 }
2130 }
Steve French4523cc32007-04-30 20:13:06 +00002131 if (pSesInfo) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2133 sb->s_maxbytes = (u64) 1 << 63;
2134 } else
2135 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2136 }
2137
Steve French8af18972007-02-14 04:42:51 +00002138 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 sb->s_time_gran = 100;
2140
2141/* on error free sesinfo and tcon struct if needed */
2142 if (rc) {
2143 /* if session setup failed, use count is zero but
2144 we still need to free cifsd thread */
Steve French4523cc32007-04-30 20:13:06 +00002145 if (atomic_read(&srvTcp->socketUseCount) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 spin_lock(&GlobalMid_Lock);
2147 srvTcp->tcpStatus = CifsExiting;
2148 spin_unlock(&GlobalMid_Lock);
Steve French4523cc32007-04-30 20:13:06 +00002149 if (srvTcp->tsk) {
Steve French28356a12007-05-23 14:45:36 +00002150 struct task_struct *tsk;
2151 /* If we could verify that kthread_stop would
2152 always wake up processes blocked in
2153 tcp in recv_mesg then we could remove the
2154 send_sig call */
Steve French50c2f752007-07-13 00:33:32 +00002155 force_sig(SIGKILL, srvTcp->tsk);
Steve French28356a12007-05-23 14:45:36 +00002156 tsk = srvTcp->tsk;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002157 if (tsk)
Steve Frenchf7f7c312007-05-24 02:29:51 +00002158 kthread_stop(tsk);
Steve Frenchf1914012005-08-18 09:37:34 -07002159 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 }
2161 /* If find_unc succeeded then rc == 0 so we can not end */
2162 if (tcon) /* up accidently freeing someone elses tcon struct */
2163 tconInfoFree(tcon);
2164 if (existingCifsSes == NULL) {
2165 if (pSesInfo) {
Steve French50c2f752007-07-13 00:33:32 +00002166 if ((pSesInfo->server) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 (pSesInfo->status == CifsGood)) {
2168 int temp_rc;
2169 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2170 /* if the socketUseCount is now zero */
Steve French4523cc32007-04-30 20:13:06 +00002171 if ((temp_rc == -ESHUTDOWN) &&
Steve French50c2f752007-07-13 00:33:32 +00002172 (pSesInfo->server) &&
Jeff5d9c7202007-06-25 22:16:35 +00002173 (pSesInfo->server->tsk)) {
Steve French28356a12007-05-23 14:45:36 +00002174 struct task_struct *tsk;
Jeff5d9c7202007-06-25 22:16:35 +00002175 force_sig(SIGKILL,
2176 pSesInfo->server->tsk);
Steve French28356a12007-05-23 14:45:36 +00002177 tsk = pSesInfo->server->tsk;
Steve Frenchf7f7c312007-05-24 02:29:51 +00002178 if (tsk)
Steve French28356a12007-05-23 14:45:36 +00002179 kthread_stop(tsk);
Steve Frenchf1914012005-08-18 09:37:34 -07002180 }
Steve Frencha0136892007-10-04 20:05:09 +00002181 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 cFYI(1, ("No session or bad tcon"));
Steve Frencha0136892007-10-04 20:05:09 +00002183 if ((pSesInfo->server) &&
2184 (pSesInfo->server->tsk)) {
2185 struct task_struct *tsk;
2186 force_sig(SIGKILL,
2187 pSesInfo->server->tsk);
2188 tsk = pSesInfo->server->tsk;
2189 if (tsk)
2190 kthread_stop(tsk);
2191 }
2192 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 sesInfoFree(pSesInfo);
2194 /* pSesInfo = NULL; */
2195 }
2196 }
2197 } else {
2198 atomic_inc(&tcon->useCount);
2199 cifs_sb->tcon = tcon;
2200 tcon->ses = pSesInfo;
2201
Steve French82940a42006-03-02 03:24:57 +00002202 /* do not care if following two calls succeed - informational */
Steve French7f8ed422007-09-28 22:28:55 +00002203 if (!tcon->ipc) {
2204 CIFSSMBQFSDeviceInfo(xid, tcon);
2205 CIFSSMBQFSAttributeInfo(xid, tcon);
2206 }
Steve French50c2f752007-07-13 00:33:32 +00002207
Steve French8af18972007-02-14 04:42:51 +00002208 /* tell server which Unix caps we support */
2209 if (tcon->ses->capabilities & CAP_UNIX)
Steve Frenchc18c8422007-07-18 23:21:09 +00002210 /* reset of caps checks mount to see if unix extensions
2211 disabled for just this mount */
Steve French8af18972007-02-14 04:42:51 +00002212 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
Steve Frenchc18c8422007-07-18 23:21:09 +00002213 else
2214 tcon->unix_ext = 0; /* server does not support them */
2215
2216 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
Steve French75865f8c2007-06-24 18:30:48 +00002217 cifs_sb->rsize = 1024 * 127;
2218#ifdef CONFIG_CIFS_DEBUG2
Steve Frenchc18c8422007-07-18 23:21:09 +00002219 cFYI(1, ("no very large read support, rsize now 127K"));
Steve French75865f8c2007-06-24 18:30:48 +00002220#endif
Steve French75865f8c2007-06-24 18:30:48 +00002221 }
Steve French3e844692005-10-03 13:37:24 -07002222 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2223 cifs_sb->wsize = min(cifs_sb->wsize,
2224 (tcon->ses->server->maxBuf -
2225 MAX_CIFS_HDR_SIZE));
Steve French0ae0efa2005-10-10 10:57:19 -07002226 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
Steve French50c2f752007-07-13 00:33:32 +00002227 cifs_sb->rsize = min(cifs_sb->rsize,
2228 (tcon->ses->server->maxBuf -
2229 MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 }
2231
2232 /* volume_info.password is freed above when existing session found
2233 (in which case it is not needed anymore) but when new sesion is created
2234 the password ptr is put in the new session structure (in which case the
2235 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002236out:
2237 /* zero out password before freeing */
2238 if (volume_info.password != NULL) {
2239 memset(volume_info.password, 0, strlen(volume_info.password));
2240 kfree(volume_info.password);
2241 }
Jesper Juhlf99d49a2005-11-07 01:01:34 -08002242 kfree(volume_info.UNC);
Steve French2fe87f02006-09-21 07:02:52 +00002243 kfree(volume_info.prepath);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 FreeXid(xid);
2245 return rc;
2246}
2247
2248static int
2249CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Steve French7c7b25b2006-06-01 19:20:10 +00002250 char session_key[CIFS_SESS_KEY_SIZE],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 const struct nls_table *nls_codepage)
2252{
2253 struct smb_hdr *smb_buffer;
2254 struct smb_hdr *smb_buffer_response;
2255 SESSION_SETUP_ANDX *pSMB;
2256 SESSION_SETUP_ANDX *pSMBr;
2257 char *bcc_ptr;
2258 char *user;
2259 char *domain;
2260 int rc = 0;
2261 int remaining_words = 0;
2262 int bytes_returned = 0;
2263 int len;
2264 __u32 capabilities;
2265 __u16 count;
2266
Steve Frencheeac8042006-01-13 21:34:58 -08002267 cFYI(1, ("In sesssetup"));
Steve French4523cc32007-04-30 20:13:06 +00002268 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269 return -EINVAL;
2270 user = ses->userName;
2271 domain = ses->domainName;
2272 smb_buffer = cifs_buf_get();
2273 if (smb_buffer == NULL) {
2274 return -ENOMEM;
2275 }
2276 smb_buffer_response = smb_buffer;
2277 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2278
2279 /* send SMBsessionSetup here */
2280 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2281 NULL /* no tCon exists yet */ , 13 /* wct */ );
2282
Steve French1982c342005-08-17 12:38:22 -07002283 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 pSMB->req_no_secext.AndXCommand = 0xFF;
2285 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2286 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2287
Steve French50c2f752007-07-13 00:33:32 +00002288 if (ses->server->secMode &
2289 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2291
2292 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2293 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2294 if (ses->capabilities & CAP_UNICODE) {
2295 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2296 capabilities |= CAP_UNICODE;
2297 }
2298 if (ses->capabilities & CAP_STATUS32) {
2299 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2300 capabilities |= CAP_STATUS32;
2301 }
2302 if (ses->capabilities & CAP_DFS) {
2303 smb_buffer->Flags2 |= SMBFLG2_DFS;
2304 capabilities |= CAP_DFS;
2305 }
2306 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2307
Steve French50c2f752007-07-13 00:33:32 +00002308 pSMB->req_no_secext.CaseInsensitivePasswordLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002309 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
2311 pSMB->req_no_secext.CaseSensitivePasswordLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002312 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 bcc_ptr = pByteArea(smb_buffer);
Steve French7c7b25b2006-06-01 19:20:10 +00002314 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2315 bcc_ptr += CIFS_SESS_KEY_SIZE;
2316 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2317 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318
2319 if (ses->capabilities & CAP_UNICODE) {
2320 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2321 *bcc_ptr = 0;
2322 bcc_ptr++;
2323 }
Steve French4523cc32007-04-30 20:13:06 +00002324 if (user == NULL)
Steve French39798772006-05-31 22:40:51 +00002325 bytes_returned = 0; /* skip null user */
Steve French50c2f752007-07-13 00:33:32 +00002326 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 bytes_returned =
Steve French50c2f752007-07-13 00:33:32 +00002328 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 nls_codepage);
2330 /* convert number of 16 bit words to bytes */
2331 bcc_ptr += 2 * bytes_returned;
2332 bcc_ptr += 2; /* trailing null */
2333 if (domain == NULL)
2334 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002335 cifs_strtoUCS((__le16 *) bcc_ptr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 "CIFS_LINUX_DOM", 32, nls_codepage);
2337 else
2338 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002339 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 nls_codepage);
2341 bcc_ptr += 2 * bytes_returned;
2342 bcc_ptr += 2;
2343 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002344 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 32, nls_codepage);
2346 bcc_ptr += 2 * bytes_returned;
2347 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002348 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 32, nls_codepage);
2350 bcc_ptr += 2 * bytes_returned;
2351 bcc_ptr += 2;
2352 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002353 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 64, nls_codepage);
2355 bcc_ptr += 2 * bytes_returned;
2356 bcc_ptr += 2;
2357 } else {
Steve French50c2f752007-07-13 00:33:32 +00002358 if (user != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 strncpy(bcc_ptr, user, 200);
2360 bcc_ptr += strnlen(user, 200);
2361 }
2362 *bcc_ptr = 0;
2363 bcc_ptr++;
2364 if (domain == NULL) {
2365 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2366 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2367 } else {
2368 strncpy(bcc_ptr, domain, 64);
2369 bcc_ptr += strnlen(domain, 64);
2370 *bcc_ptr = 0;
2371 bcc_ptr++;
2372 }
2373 strcpy(bcc_ptr, "Linux version ");
2374 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002375 strcpy(bcc_ptr, utsname()->release);
2376 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2378 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2379 }
2380 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2381 smb_buffer->smb_buf_length += count;
2382 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2383
2384 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00002385 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 if (rc) {
2387/* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2388 } else if ((smb_buffer_response->WordCount == 3)
2389 || (smb_buffer_response->WordCount == 4)) {
2390 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2391 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2392 if (action & GUEST_LOGIN)
Steve French50c2f752007-07-13 00:33:32 +00002393 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2394 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2395 (little endian) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 cFYI(1, ("UID = %d ", ses->Suid));
Steve French50c2f752007-07-13 00:33:32 +00002397 /* response can have either 3 or 4 word count - Samba sends 3 */
2398 bcc_ptr = pByteArea(smb_buffer_response);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 if ((pSMBr->resp.hdr.WordCount == 3)
2400 || ((pSMBr->resp.hdr.WordCount == 4)
2401 && (blob_len < pSMBr->resp.ByteCount))) {
2402 if (pSMBr->resp.hdr.WordCount == 4)
2403 bcc_ptr += blob_len;
2404
2405 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2406 if ((long) (bcc_ptr) % 2) {
2407 remaining_words =
Steve French50c2f752007-07-13 00:33:32 +00002408 (BCC(smb_buffer_response) - 1) / 2;
2409 /* Unicode strings must be word
2410 aligned */
2411 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 } else {
2413 remaining_words =
2414 BCC(smb_buffer_response) / 2;
2415 }
2416 len =
2417 UniStrnlen((wchar_t *) bcc_ptr,
2418 remaining_words - 1);
2419/* We look for obvious messed up bcc or strings in response so we do not go off
2420 the end since (at least) WIN2K and Windows XP have a major bug in not null
2421 terminating last Unicode string in response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002422 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00002423 kfree(ses->serverOS);
Steve French50c2f752007-07-13 00:33:32 +00002424 ses->serverOS = kzalloc(2 * (len + 1),
2425 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002426 if (ses->serverOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002427 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 cifs_strfromUCS_le(ses->serverOS,
Steve French50c2f752007-07-13 00:33:32 +00002429 (__le16 *)bcc_ptr,
2430 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 bcc_ptr += 2 * (len + 1);
2432 remaining_words -= len + 1;
2433 ses->serverOS[2 * len] = 0;
2434 ses->serverOS[1 + (2 * len)] = 0;
2435 if (remaining_words > 0) {
2436 len = UniStrnlen((wchar_t *)bcc_ptr,
2437 remaining_words-1);
Steve Frenchcd49b492006-06-26 04:22:36 +00002438 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00002439 ses->serverNOS = kzalloc(2 * (len + 1),
2440 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002441 if (ses->serverNOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002442 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 cifs_strfromUCS_le(ses->serverNOS,
Steve French50c2f752007-07-13 00:33:32 +00002444 (__le16 *)bcc_ptr,
2445 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 bcc_ptr += 2 * (len + 1);
2447 ses->serverNOS[2 * len] = 0;
2448 ses->serverNOS[1 + (2 * len)] = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002449 if (strncmp(ses->serverNOS,
Steve French50c2f752007-07-13 00:33:32 +00002450 "NT LAN Manager 4", 16) == 0) {
Steve French467a8f82007-06-27 22:41:32 +00002451 cFYI(1, ("NT4 server"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 ses->flags |= CIFS_SES_NT4;
2453 }
2454 remaining_words -= len + 1;
2455 if (remaining_words > 0) {
Steve French433dc242005-04-28 22:41:08 -07002456 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Steve French50c2f752007-07-13 00:33:32 +00002457 /* last string is not always null terminated
2458 (for e.g. for Windows XP & 2000) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002459 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00002460 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 ses->serverDomain =
Steve French50c2f752007-07-13 00:33:32 +00002462 kzalloc(2*(len+1),
2463 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002464 if (ses->serverDomain == NULL)
Steve French433dc242005-04-28 22:41:08 -07002465 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 cifs_strfromUCS_le(ses->serverDomain,
Steve French50c2f752007-07-13 00:33:32 +00002467 (__le16 *)bcc_ptr,
2468 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 bcc_ptr += 2 * (len + 1);
2470 ses->serverDomain[2*len] = 0;
2471 ses->serverDomain[1+(2*len)] = 0;
Steve French50c2f752007-07-13 00:33:32 +00002472 } else { /* else no more room so create
2473 dummy domain string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002474 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00002475 kfree(ses->serverDomain);
Steve French50c2f752007-07-13 00:33:32 +00002476 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002477 kzalloc(2, GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00002478 }
Steve French50c2f752007-07-13 00:33:32 +00002479 } else { /* no room so create dummy domain
2480 and NOS string */
2481
Steve French433dc242005-04-28 22:41:08 -07002482 /* if these kcallocs fail not much we
2483 can do, but better to not fail the
2484 sesssetup itself */
Steve Frenchcd49b492006-06-26 04:22:36 +00002485 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002487 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00002488 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002490 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 }
2492 } else { /* ASCII */
2493 len = strnlen(bcc_ptr, 1024);
2494 if (((long) bcc_ptr + len) - (long)
2495 pByteArea(smb_buffer_response)
2496 <= BCC(smb_buffer_response)) {
Steve Frenchcd49b492006-06-26 04:22:36 +00002497 kfree(ses->serverOS);
Steve French50c2f752007-07-13 00:33:32 +00002498 ses->serverOS = kzalloc(len + 1,
2499 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002500 if (ses->serverOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002501 goto sesssetup_nomem;
Steve French50c2f752007-07-13 00:33:32 +00002502 strncpy(ses->serverOS, bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503
2504 bcc_ptr += len;
Steve French50c2f752007-07-13 00:33:32 +00002505 /* null terminate the string */
2506 bcc_ptr[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507 bcc_ptr++;
2508
2509 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002510 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00002511 ses->serverNOS = kzalloc(len + 1,
2512 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002513 if (ses->serverNOS == NULL)
Steve French433dc242005-04-28 22:41:08 -07002514 goto sesssetup_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 strncpy(ses->serverNOS, bcc_ptr, len);
2516 bcc_ptr += len;
2517 bcc_ptr[0] = 0;
2518 bcc_ptr++;
2519
2520 len = strnlen(bcc_ptr, 1024);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002521 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00002522 kfree(ses->serverDomain);
Steve French50c2f752007-07-13 00:33:32 +00002523 ses->serverDomain = kzalloc(len + 1,
2524 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002525 if (ses->serverDomain == NULL)
Steve French433dc242005-04-28 22:41:08 -07002526 goto sesssetup_nomem;
Steve French50c2f752007-07-13 00:33:32 +00002527 strncpy(ses->serverDomain, bcc_ptr,
2528 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 bcc_ptr += len;
2530 bcc_ptr[0] = 0;
2531 bcc_ptr++;
2532 } else
2533 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00002534 ("Variable field of length %d "
2535 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 len));
2537 }
2538 } else {
2539 cERROR(1,
Steve French50c2f752007-07-13 00:33:32 +00002540 (" Security Blob Length extends beyond "
2541 "end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 }
2543 } else {
2544 cERROR(1,
2545 (" Invalid Word count %d: ",
2546 smb_buffer_response->WordCount));
2547 rc = -EIO;
2548 }
Steve French433dc242005-04-28 22:41:08 -07002549sesssetup_nomem: /* do not return an error on nomem for the info strings,
2550 since that could make reconnection harder, and
2551 reconnection might be needed to free memory */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002552 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553
2554 return rc;
2555}
2556
2557static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
Steve French50c2f752007-07-13 00:33:32 +00002559 struct cifsSesInfo *ses, int *pNTLMv2_flag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 const struct nls_table *nls_codepage)
2561{
2562 struct smb_hdr *smb_buffer;
2563 struct smb_hdr *smb_buffer_response;
2564 SESSION_SETUP_ANDX *pSMB;
2565 SESSION_SETUP_ANDX *pSMBr;
2566 char *bcc_ptr;
2567 char *domain;
2568 int rc = 0;
2569 int remaining_words = 0;
2570 int bytes_returned = 0;
2571 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002572 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 PNEGOTIATE_MESSAGE SecurityBlob;
2574 PCHALLENGE_MESSAGE SecurityBlob2;
2575 __u32 negotiate_flags, capabilities;
2576 __u16 count;
2577
Steve French12b3b8f2006-02-09 21:12:47 +00002578 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002579 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 return -EINVAL;
2581 domain = ses->domainName;
2582 *pNTLMv2_flag = FALSE;
2583 smb_buffer = cifs_buf_get();
2584 if (smb_buffer == NULL) {
2585 return -ENOMEM;
2586 }
2587 smb_buffer_response = smb_buffer;
2588 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2589 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2590
2591 /* send SMBsessionSetup here */
2592 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2593 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002594
2595 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2597 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2598
2599 pSMB->req.AndXCommand = 0xFF;
2600 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2601 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2602
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002603 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2605
2606 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2607 CAP_EXTENDED_SECURITY;
2608 if (ses->capabilities & CAP_UNICODE) {
2609 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2610 capabilities |= CAP_UNICODE;
2611 }
2612 if (ses->capabilities & CAP_STATUS32) {
2613 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2614 capabilities |= CAP_STATUS32;
2615 }
2616 if (ses->capabilities & CAP_DFS) {
2617 smb_buffer->Flags2 |= SMBFLG2_DFS;
2618 capabilities |= CAP_DFS;
2619 }
2620 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2621
2622 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2623 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2624 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2625 SecurityBlob->MessageType = NtLmNegotiate;
2626 negotiate_flags =
2627 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
Steve French12b3b8f2006-02-09 21:12:47 +00002628 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2629 NTLMSSP_NEGOTIATE_56 |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002631 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002633/* if (ntlmv2_support)
Steve French39798772006-05-31 22:40:51 +00002634 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 /* setup pointers to domain name and workstation name */
2636 bcc_ptr += SecurityBlobLength;
2637
2638 SecurityBlob->WorkstationName.Buffer = 0;
2639 SecurityBlob->WorkstationName.Length = 0;
2640 SecurityBlob->WorkstationName.MaximumLength = 0;
2641
Steve French12b3b8f2006-02-09 21:12:47 +00002642 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2643 along with username on auth request (ie the response to challenge) */
2644 SecurityBlob->DomainName.Buffer = 0;
2645 SecurityBlob->DomainName.Length = 0;
2646 SecurityBlob->DomainName.MaximumLength = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 if (ses->capabilities & CAP_UNICODE) {
2648 if ((long) bcc_ptr % 2) {
2649 *bcc_ptr = 0;
2650 bcc_ptr++;
2651 }
2652
2653 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002654 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 32, nls_codepage);
2656 bcc_ptr += 2 * bytes_returned;
2657 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002658 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 nls_codepage);
2660 bcc_ptr += 2 * bytes_returned;
2661 bcc_ptr += 2; /* null terminate Linux version */
2662 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08002663 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 64, nls_codepage);
2665 bcc_ptr += 2 * bytes_returned;
2666 *(bcc_ptr + 1) = 0;
2667 *(bcc_ptr + 2) = 0;
2668 bcc_ptr += 2; /* null terminate network opsys string */
2669 *(bcc_ptr + 1) = 0;
2670 *(bcc_ptr + 2) = 0;
2671 bcc_ptr += 2; /* null domain */
2672 } else { /* ASCII */
2673 strcpy(bcc_ptr, "Linux version ");
2674 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07002675 strcpy(bcc_ptr, utsname()->release);
2676 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2678 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2679 bcc_ptr++; /* empty domain field */
2680 *bcc_ptr = 0;
2681 }
2682 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2683 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2684 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2685 smb_buffer->smb_buf_length += count;
2686 pSMB->req.ByteCount = cpu_to_le16(count);
2687
2688 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00002689 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690
2691 if (smb_buffer_response->Status.CifsError ==
2692 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2693 rc = 0;
2694
2695 if (rc) {
2696/* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2697 } else if ((smb_buffer_response->WordCount == 3)
2698 || (smb_buffer_response->WordCount == 4)) {
2699 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2700 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2701
2702 if (action & GUEST_LOGIN)
Steve French50c2f752007-07-13 00:33:32 +00002703 cFYI(1, (" Guest login"));
2704 /* Do we want to set anything in SesInfo struct when guest login? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705
Steve French50c2f752007-07-13 00:33:32 +00002706 bcc_ptr = pByteArea(smb_buffer_response);
2707 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708
2709 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2710 if (SecurityBlob2->MessageType != NtLmChallenge) {
2711 cFYI(1,
2712 ("Unexpected NTLMSSP message type received %d",
2713 SecurityBlob2->MessageType));
2714 } else if (ses) {
Steve French50c2f752007-07-13 00:33:32 +00002715 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
Steve French12b3b8f2006-02-09 21:12:47 +00002716 cFYI(1, ("UID = %d", ses->Suid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 if ((pSMBr->resp.hdr.WordCount == 3)
2718 || ((pSMBr->resp.hdr.WordCount == 4)
2719 && (blob_len <
2720 pSMBr->resp.ByteCount))) {
2721
2722 if (pSMBr->resp.hdr.WordCount == 4) {
2723 bcc_ptr += blob_len;
Steve French12b3b8f2006-02-09 21:12:47 +00002724 cFYI(1, ("Security Blob Length %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 blob_len));
2726 }
2727
Steve French12b3b8f2006-02-09 21:12:47 +00002728 cFYI(1, ("NTLMSSP Challenge rcvd"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729
2730 memcpy(ses->server->cryptKey,
2731 SecurityBlob2->Challenge,
2732 CIFS_CRYPTO_KEY_SIZE);
Steve French50c2f752007-07-13 00:33:32 +00002733 if (SecurityBlob2->NegotiateFlags &
Steve French12b3b8f2006-02-09 21:12:47 +00002734 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 *pNTLMv2_flag = TRUE;
2736
Steve French50c2f752007-07-13 00:33:32 +00002737 if ((SecurityBlob2->NegotiateFlags &
2738 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 || (sign_CIFS_PDUs > 1))
Steve French50c2f752007-07-13 00:33:32 +00002740 ses->server->secMode |=
2741 SECMODE_SIGN_REQUIRED;
2742 if ((SecurityBlob2->NegotiateFlags &
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
Steve French50c2f752007-07-13 00:33:32 +00002744 ses->server->secMode |=
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 SECMODE_SIGN_ENABLED;
2746
2747 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2748 if ((long) (bcc_ptr) % 2) {
2749 remaining_words =
2750 (BCC(smb_buffer_response)
2751 - 1) / 2;
Steve French50c2f752007-07-13 00:33:32 +00002752 /* Must word align unicode strings */
2753 bcc_ptr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 } else {
2755 remaining_words =
2756 BCC
2757 (smb_buffer_response) / 2;
2758 }
2759 len =
2760 UniStrnlen((wchar_t *) bcc_ptr,
2761 remaining_words - 1);
2762/* We look for obvious messed up bcc or strings in response so we do not go off
2763 the end since (at least) WIN2K and Windows XP have a major bug in not null
2764 terminating last Unicode string in response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002765 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00002766 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002768 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08002770 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 bcc_ptr, len,
2772 nls_codepage);
2773 bcc_ptr += 2 * (len + 1);
2774 remaining_words -= len + 1;
2775 ses->serverOS[2 * len] = 0;
2776 ses->serverOS[1 + (2 * len)] = 0;
2777 if (remaining_words > 0) {
2778 len = UniStrnlen((wchar_t *)
2779 bcc_ptr,
2780 remaining_words
2781 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00002782 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002784 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 GFP_KERNEL);
2786 cifs_strfromUCS_le(ses->
2787 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08002788 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 bcc_ptr,
2790 len,
2791 nls_codepage);
2792 bcc_ptr += 2 * (len + 1);
2793 ses->serverNOS[2 * len] = 0;
2794 ses->serverNOS[1 +
2795 (2 * len)] = 0;
2796 remaining_words -= len + 1;
2797 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00002798 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2799 /* last string not always null terminated
2800 (for e.g. for Windows XP & 2000) */
Steve Frenchcd49b492006-06-26 04:22:36 +00002801 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002803 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 (len +
2805 1),
2806 GFP_KERNEL);
2807 cifs_strfromUCS_le
Steve Frenche89dc922005-11-11 15:18:19 -08002808 (ses->serverDomain,
2809 (__le16 *)bcc_ptr,
2810 len, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 bcc_ptr +=
2812 2 * (len + 1);
Steve Frenche89dc922005-11-11 15:18:19 -08002813 ses->serverDomain[2*len]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814 = 0;
Steve Frenche89dc922005-11-11 15:18:19 -08002815 ses->serverDomain
2816 [1 + (2 * len)]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 = 0;
2818 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00002819 else {
Steve Frenchcd49b492006-06-26 04:22:36 +00002820 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002822 kzalloc(2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00002824 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 } else { /* no room so create dummy domain and NOS string */
Steve Frenchcd49b492006-06-26 04:22:36 +00002826 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002828 kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00002829 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002831 kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 }
2833 } else { /* ASCII */
2834 len = strnlen(bcc_ptr, 1024);
2835 if (((long) bcc_ptr + len) - (long)
2836 pByteArea(smb_buffer_response)
2837 <= BCC(smb_buffer_response)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002838 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00002839 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002841 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 GFP_KERNEL);
2843 strncpy(ses->serverOS,
2844 bcc_ptr, len);
2845
2846 bcc_ptr += len;
2847 bcc_ptr[0] = 0; /* null terminate string */
2848 bcc_ptr++;
2849
2850 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002851 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07002853 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 GFP_KERNEL);
2855 strncpy(ses->serverNOS, bcc_ptr, len);
2856 bcc_ptr += len;
2857 bcc_ptr[0] = 0;
2858 bcc_ptr++;
2859
2860 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00002861 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07002863 kzalloc(len + 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +00002865 strncpy(ses->serverDomain,
2866 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 bcc_ptr += len;
2868 bcc_ptr[0] = 0;
2869 bcc_ptr++;
2870 } else
2871 cFYI(1,
Steve French63135e02007-07-17 17:34:02 +00002872 ("field of length %d "
2873 "extends beyond end of smb",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 len));
2875 }
2876 } else {
Steve French50c2f752007-07-13 00:33:32 +00002877 cERROR(1, ("Security Blob Length extends beyond"
2878 " end of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 }
2880 } else {
2881 cERROR(1, ("No session structure passed in."));
2882 }
2883 } else {
2884 cERROR(1,
Steve French5815449d2006-02-14 01:36:20 +00002885 (" Invalid Word count %d:",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 smb_buffer_response->WordCount));
2887 rc = -EIO;
2888 }
2889
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002890 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891
2892 return rc;
2893}
2894static int
2895CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002896 char *ntlm_session_key, int ntlmv2_flag,
2897 const struct nls_table *nls_codepage)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898{
2899 struct smb_hdr *smb_buffer;
2900 struct smb_hdr *smb_buffer_response;
2901 SESSION_SETUP_ANDX *pSMB;
2902 SESSION_SETUP_ANDX *pSMBr;
2903 char *bcc_ptr;
2904 char *user;
2905 char *domain;
2906 int rc = 0;
2907 int remaining_words = 0;
2908 int bytes_returned = 0;
2909 int len;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002910 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 PAUTHENTICATE_MESSAGE SecurityBlob;
2912 __u32 negotiate_flags, capabilities;
2913 __u16 count;
2914
2915 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002916 if (ses == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 return -EINVAL;
2918 user = ses->userName;
2919 domain = ses->domainName;
2920 smb_buffer = cifs_buf_get();
2921 if (smb_buffer == NULL) {
2922 return -ENOMEM;
2923 }
2924 smb_buffer_response = smb_buffer;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002925 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2926 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927
2928 /* send SMBsessionSetup here */
2929 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2930 NULL /* no tCon exists yet */ , 12 /* wct */ );
Steve French1982c342005-08-17 12:38:22 -07002931
2932 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2934 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2935 pSMB->req.AndXCommand = 0xFF;
2936 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2937 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2938
2939 pSMB->req.hdr.Uid = ses->Suid;
2940
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002941 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2943
2944 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002945 CAP_EXTENDED_SECURITY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946 if (ses->capabilities & CAP_UNICODE) {
2947 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2948 capabilities |= CAP_UNICODE;
2949 }
2950 if (ses->capabilities & CAP_STATUS32) {
2951 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2952 capabilities |= CAP_STATUS32;
2953 }
2954 if (ses->capabilities & CAP_DFS) {
2955 smb_buffer->Flags2 |= SMBFLG2_DFS;
2956 capabilities |= CAP_DFS;
2957 }
2958 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2959
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002960 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
2961 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2963 SecurityBlob->MessageType = NtLmAuthenticate;
2964 bcc_ptr += SecurityBlobLength;
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00002965 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
2966 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
2967 0x80000000 | NTLMSSP_NEGOTIATE_128;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002968 if (sign_CIFS_PDUs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002970 if (ntlmv2_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
2972
2973/* setup pointers to domain name and workstation name */
2974
2975 SecurityBlob->WorkstationName.Buffer = 0;
2976 SecurityBlob->WorkstationName.Length = 0;
2977 SecurityBlob->WorkstationName.MaximumLength = 0;
2978 SecurityBlob->SessionKey.Length = 0;
2979 SecurityBlob->SessionKey.MaximumLength = 0;
2980 SecurityBlob->SessionKey.Buffer = 0;
2981
2982 SecurityBlob->LmChallengeResponse.Length = 0;
2983 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
2984 SecurityBlob->LmChallengeResponse.Buffer = 0;
2985
2986 SecurityBlob->NtChallengeResponse.Length =
Steve French7c7b25b2006-06-01 19:20:10 +00002987 cpu_to_le16(CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988 SecurityBlob->NtChallengeResponse.MaximumLength =
Steve French7c7b25b2006-06-01 19:20:10 +00002989 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2990 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 SecurityBlob->NtChallengeResponse.Buffer =
2992 cpu_to_le32(SecurityBlobLength);
Steve French7c7b25b2006-06-01 19:20:10 +00002993 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
2994 bcc_ptr += CIFS_SESS_KEY_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995
2996 if (ses->capabilities & CAP_UNICODE) {
2997 if (domain == NULL) {
2998 SecurityBlob->DomainName.Buffer = 0;
2999 SecurityBlob->DomainName.Length = 0;
3000 SecurityBlob->DomainName.MaximumLength = 0;
3001 } else {
Steve French77159b42007-08-31 01:10:17 +00003002 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003004 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003006 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 SecurityBlob->DomainName.Buffer =
3008 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003009 bcc_ptr += ln;
3010 SecurityBlobLength += ln;
3011 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 }
3013 if (user == NULL) {
3014 SecurityBlob->UserName.Buffer = 0;
3015 SecurityBlob->UserName.Length = 0;
3016 SecurityBlob->UserName.MaximumLength = 0;
3017 } else {
Steve French77159b42007-08-31 01:10:17 +00003018 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 nls_codepage);
Steve French77159b42007-08-31 01:10:17 +00003020 ln *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 SecurityBlob->UserName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003022 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 SecurityBlob->UserName.Buffer =
3024 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003025 bcc_ptr += ln;
3026 SecurityBlobLength += ln;
3027 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 }
3029
Steve French63135e02007-07-17 17:34:02 +00003030 /* SecurityBlob->WorkstationName.Length =
3031 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 SecurityBlob->WorkstationName.Length *= 2;
Steve French63135e02007-07-17 17:34:02 +00003033 SecurityBlob->WorkstationName.MaximumLength =
3034 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3035 SecurityBlob->WorkstationName.Buffer =
3036 cpu_to_le32(SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 bcc_ptr += SecurityBlob->WorkstationName.Length;
3038 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
Steve French63135e02007-07-17 17:34:02 +00003039 SecurityBlob->WorkstationName.Length =
3040 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041
3042 if ((long) bcc_ptr % 2) {
3043 *bcc_ptr = 0;
3044 bcc_ptr++;
3045 }
3046 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003047 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 32, nls_codepage);
3049 bcc_ptr += 2 * bytes_returned;
3050 bytes_returned =
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003051 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 nls_codepage);
3053 bcc_ptr += 2 * bytes_returned;
3054 bcc_ptr += 2; /* null term version string */
3055 bytes_returned =
Steve Frenche89dc922005-11-11 15:18:19 -08003056 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057 64, nls_codepage);
3058 bcc_ptr += 2 * bytes_returned;
3059 *(bcc_ptr + 1) = 0;
3060 *(bcc_ptr + 2) = 0;
3061 bcc_ptr += 2; /* null terminate network opsys string */
3062 *(bcc_ptr + 1) = 0;
3063 *(bcc_ptr + 2) = 0;
3064 bcc_ptr += 2; /* null domain */
3065 } else { /* ASCII */
3066 if (domain == NULL) {
3067 SecurityBlob->DomainName.Buffer = 0;
3068 SecurityBlob->DomainName.Length = 0;
3069 SecurityBlob->DomainName.MaximumLength = 0;
3070 } else {
Steve French77159b42007-08-31 01:10:17 +00003071 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3073 strncpy(bcc_ptr, domain, 63);
Steve French77159b42007-08-31 01:10:17 +00003074 ln = strnlen(domain, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075 SecurityBlob->DomainName.MaximumLength =
Steve French77159b42007-08-31 01:10:17 +00003076 cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077 SecurityBlob->DomainName.Buffer =
3078 cpu_to_le32(SecurityBlobLength);
Steve French77159b42007-08-31 01:10:17 +00003079 bcc_ptr += ln;
3080 SecurityBlobLength += ln;
3081 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 }
3083 if (user == NULL) {
3084 SecurityBlob->UserName.Buffer = 0;
3085 SecurityBlob->UserName.Length = 0;
3086 SecurityBlob->UserName.MaximumLength = 0;
3087 } else {
Steve French77159b42007-08-31 01:10:17 +00003088 __u16 ln;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089 strncpy(bcc_ptr, user, 63);
Steve French77159b42007-08-31 01:10:17 +00003090 ln = strnlen(user, 64);
3091 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 SecurityBlob->UserName.Buffer =
Steve French77159b42007-08-31 01:10:17 +00003093 cpu_to_le32(SecurityBlobLength);
3094 bcc_ptr += ln;
3095 SecurityBlobLength += ln;
3096 SecurityBlob->UserName.Length = cpu_to_le16(ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 }
3098 /* BB fill in our workstation name if known BB */
3099
3100 strcpy(bcc_ptr, "Linux version ");
3101 bcc_ptr += strlen("Linux version ");
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07003102 strcpy(bcc_ptr, utsname()->release);
3103 bcc_ptr += strlen(utsname()->release) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3105 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3106 bcc_ptr++; /* null domain */
3107 *bcc_ptr = 0;
3108 }
3109 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3110 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3111 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3112 smb_buffer->smb_buf_length += count;
3113 pSMB->req.ByteCount = cpu_to_le16(count);
3114
3115 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
Steve French133672e2007-11-13 22:41:37 +00003116 &bytes_returned, CIFS_LONG_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 if (rc) {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003118/* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3119 } else if ((smb_buffer_response->WordCount == 3) ||
3120 (smb_buffer_response->WordCount == 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 __u16 action = le16_to_cpu(pSMBr->resp.Action);
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003122 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 if (action & GUEST_LOGIN)
Steve French50c2f752007-07-13 00:33:32 +00003124 cFYI(1, (" Guest login")); /* BB Should we set anything
3125 in SesInfo struct ? */
3126/* if (SecurityBlob2->MessageType != NtLm??) {
3127 cFYI("Unexpected message type on auth response is %d"));
3128 } */
3129
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130 if (ses) {
3131 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00003132 ("Check challenge UID %d vs auth response UID %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003133 ses->Suid, smb_buffer_response->Uid));
Steve French50c2f752007-07-13 00:33:32 +00003134 /* UID left in wire format */
3135 ses->Suid = smb_buffer_response->Uid;
3136 bcc_ptr = pByteArea(smb_buffer_response);
3137 /* response can have either 3 or 4 word count - Samba sends 3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 if ((pSMBr->resp.hdr.WordCount == 3)
3139 || ((pSMBr->resp.hdr.WordCount == 4)
3140 && (blob_len <
3141 pSMBr->resp.ByteCount))) {
3142 if (pSMBr->resp.hdr.WordCount == 4) {
3143 bcc_ptr +=
3144 blob_len;
3145 cFYI(1,
3146 ("Security Blob Length %d ",
3147 blob_len));
3148 }
3149
3150 cFYI(1,
3151 ("NTLMSSP response to Authenticate "));
3152
3153 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3154 if ((long) (bcc_ptr) % 2) {
3155 remaining_words =
3156 (BCC(smb_buffer_response)
3157 - 1) / 2;
3158 bcc_ptr++; /* Unicode strings must be word aligned */
3159 } else {
3160 remaining_words = BCC(smb_buffer_response) / 2;
3161 }
Steve French77159b42007-08-31 01:10:17 +00003162 len = UniStrnlen((wchar_t *) bcc_ptr,
3163 remaining_words - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164/* We look for obvious messed up bcc or strings in response so we do not go off
3165 the end since (at least) WIN2K and Windows XP have a major bug in not null
3166 terminating last Unicode string in response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003167 if (ses->serverOS)
Steve French08775832006-05-30 18:08:26 +00003168 kfree(ses->serverOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 ses->serverOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003170 kzalloc(2 * (len + 1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 cifs_strfromUCS_le(ses->serverOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003172 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003173 bcc_ptr, len,
3174 nls_codepage);
3175 bcc_ptr += 2 * (len + 1);
3176 remaining_words -= len + 1;
3177 ses->serverOS[2 * len] = 0;
3178 ses->serverOS[1 + (2 * len)] = 0;
3179 if (remaining_words > 0) {
3180 len = UniStrnlen((wchar_t *)
3181 bcc_ptr,
3182 remaining_words
3183 - 1);
Steve Frenchcd49b492006-06-26 04:22:36 +00003184 kfree(ses->serverNOS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003185 ses->serverNOS =
Pekka Enberge915fc42005-09-06 15:18:35 -07003186 kzalloc(2 * (len + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 GFP_KERNEL);
3188 cifs_strfromUCS_le(ses->
3189 serverNOS,
Steve Frenche89dc922005-11-11 15:18:19 -08003190 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 bcc_ptr,
3192 len,
3193 nls_codepage);
3194 bcc_ptr += 2 * (len + 1);
3195 ses->serverNOS[2 * len] = 0;
3196 ses->serverNOS[1+(2*len)] = 0;
3197 remaining_words -= len + 1;
3198 if (remaining_words > 0) {
Steve French50c2f752007-07-13 00:33:32 +00003199 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200 /* last string not always null terminated (e.g. for Windows XP & 2000) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003201 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003202 kfree(ses->serverDomain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 ses->serverDomain =
Pekka Enberge915fc42005-09-06 15:18:35 -07003204 kzalloc(2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205 (len +
3206 1),
3207 GFP_KERNEL);
3208 cifs_strfromUCS_le
3209 (ses->
3210 serverDomain,
Steve Frenche89dc922005-11-11 15:18:19 -08003211 (__le16 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212 bcc_ptr, len,
3213 nls_codepage);
3214 bcc_ptr +=
3215 2 * (len + 1);
3216 ses->
3217 serverDomain[2
3218 * len]
3219 = 0;
3220 ses->
3221 serverDomain[1
3222 +
3223 (2
3224 *
3225 len)]
3226 = 0;
3227 } /* else no more room so create dummy domain string */
Steve Frencha424f8b2006-05-30 18:06:04 +00003228 else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003229 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003230 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003231 ses->serverDomain = kzalloc(2,GFP_KERNEL);
Steve Frencha424f8b2006-05-30 18:06:04 +00003232 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233 } else { /* no room so create dummy domain and NOS string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003234 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003235 kfree(ses->serverDomain);
Pekka Enberge915fc42005-09-06 15:18:35 -07003236 ses->serverDomain = kzalloc(2, GFP_KERNEL);
Steve Frenchcd49b492006-06-26 04:22:36 +00003237 kfree(ses->serverNOS);
Pekka Enberge915fc42005-09-06 15:18:35 -07003238 ses->serverNOS = kzalloc(2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239 }
3240 } else { /* ASCII */
3241 len = strnlen(bcc_ptr, 1024);
Steve French50c2f752007-07-13 00:33:32 +00003242 if (((long) bcc_ptr + len) -
3243 (long) pByteArea(smb_buffer_response)
Steve French63135e02007-07-17 17:34:02 +00003244 <= BCC(smb_buffer_response)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003245 if (ses->serverOS)
Steve Frencha424f8b2006-05-30 18:06:04 +00003246 kfree(ses->serverOS);
Steve French77159b42007-08-31 01:10:17 +00003247 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003248 strncpy(ses->serverOS,bcc_ptr, len);
3249
3250 bcc_ptr += len;
3251 bcc_ptr[0] = 0; /* null terminate the string */
3252 bcc_ptr++;
3253
3254 len = strnlen(bcc_ptr, 1024);
Steve Frenchcd49b492006-06-26 04:22:36 +00003255 kfree(ses->serverNOS);
Steve French50c2f752007-07-13 00:33:32 +00003256 ses->serverNOS = kzalloc(len+1,
3257 GFP_KERNEL);
Steve French63135e02007-07-17 17:34:02 +00003258 strncpy(ses->serverNOS,
3259 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260 bcc_ptr += len;
3261 bcc_ptr[0] = 0;
3262 bcc_ptr++;
3263
3264 len = strnlen(bcc_ptr, 1024);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003265 if (ses->serverDomain)
Steve Frencha424f8b2006-05-30 18:06:04 +00003266 kfree(ses->serverDomain);
Steve French63135e02007-07-17 17:34:02 +00003267 ses->serverDomain =
3268 kzalloc(len+1,
3269 GFP_KERNEL);
3270 strncpy(ses->serverDomain,
3271 bcc_ptr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272 bcc_ptr += len;
3273 bcc_ptr[0] = 0;
3274 bcc_ptr++;
3275 } else
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003276 cFYI(1, ("field of length %d "
Steve French63135e02007-07-17 17:34:02 +00003277 "extends beyond end of smb ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 len));
3279 }
3280 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003281 cERROR(1, ("Security Blob extends beyond end "
Steve French63135e02007-07-17 17:34:02 +00003282 "of SMB"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003283 }
3284 } else {
3285 cERROR(1, ("No session structure passed in."));
3286 }
3287 } else {
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00003288 cERROR(1, ("Invalid Word count %d: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 smb_buffer_response->WordCount));
3290 rc = -EIO;
3291 }
3292
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003293 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003294
3295 return rc;
3296}
3297
3298int
3299CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3300 const char *tree, struct cifsTconInfo *tcon,
3301 const struct nls_table *nls_codepage)
3302{
3303 struct smb_hdr *smb_buffer;
3304 struct smb_hdr *smb_buffer_response;
3305 TCONX_REQ *pSMB;
3306 TCONX_RSP *pSMBr;
3307 unsigned char *bcc_ptr;
3308 int rc = 0;
3309 int length;
3310 __u16 count;
3311
3312 if (ses == NULL)
3313 return -EIO;
3314
3315 smb_buffer = cifs_buf_get();
3316 if (smb_buffer == NULL) {
3317 return -ENOMEM;
3318 }
3319 smb_buffer_response = smb_buffer;
3320
3321 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3322 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003323
3324 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325 smb_buffer->Uid = ses->Suid;
3326 pSMB = (TCONX_REQ *) smb_buffer;
3327 pSMBr = (TCONX_RSP *) smb_buffer_response;
3328
3329 pSMB->AndXCommand = 0xFF;
3330 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003332 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08003333 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003334 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003335 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003336 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003337 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00003338 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003339 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3340 specified as required (when that support is added to
3341 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003342 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003343 by Samba (not sure whether other servers allow
3344 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003345#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French50c2f752007-07-13 00:33:32 +00003346 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
Steve French7c7b25b2006-06-01 19:20:10 +00003347 (ses->server->secType == LANMAN))
3348 calc_lanman_hash(ses, bcc_ptr);
3349 else
3350#endif /* CIFS_WEAK_PW_HASH */
Steve Frencheeac8042006-01-13 21:34:58 -08003351 SMBNTencrypt(ses->password,
3352 ses->server->cryptKey,
3353 bcc_ptr);
3354
Steve French7c7b25b2006-06-01 19:20:10 +00003355 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003356 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003357 /* must align unicode strings */
3358 *bcc_ptr = 0; /* null byte password */
3359 bcc_ptr++;
3360 }
Steve Frencheeac8042006-01-13 21:34:58 -08003361 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362
Steve French50c2f752007-07-13 00:33:32 +00003363 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003364 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3366
3367 if (ses->capabilities & CAP_STATUS32) {
3368 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3369 }
3370 if (ses->capabilities & CAP_DFS) {
3371 smb_buffer->Flags2 |= SMBFLG2_DFS;
3372 }
3373 if (ses->capabilities & CAP_UNICODE) {
3374 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3375 length =
Steve French50c2f752007-07-13 00:33:32 +00003376 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3377 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003378 (/* server len*/ + 256 /* share len */), nls_codepage);
3379 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 bcc_ptr += 2; /* skip trailing null */
3381 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382 strcpy(bcc_ptr, tree);
3383 bcc_ptr += strlen(tree) + 1;
3384 }
3385 strcpy(bcc_ptr, "?????");
3386 bcc_ptr += strlen("?????");
3387 bcc_ptr += 1;
3388 count = bcc_ptr - &pSMB->Password[0];
3389 pSMB->hdr.smb_buf_length += count;
3390 pSMB->ByteCount = cpu_to_le16(count);
3391
Steve French133672e2007-11-13 22:41:37 +00003392 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3393 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003394
3395 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3396 /* above now done in SendReceive */
3397 if ((rc == 0) && (tcon != NULL)) {
3398 tcon->tidStatus = CifsGood;
3399 tcon->tid = smb_buffer_response->Tid;
3400 bcc_ptr = pByteArea(smb_buffer_response);
3401 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
Steve French50c2f752007-07-13 00:33:32 +00003402 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003403 if (length == 3) {
3404 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3405 (bcc_ptr[2] == 'C')) {
3406 cFYI(1, ("IPC connection"));
3407 tcon->ipc = 1;
3408 }
3409 } else if (length == 2) {
3410 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3411 /* the most common case */
3412 cFYI(1, ("disk share connection"));
3413 }
3414 }
Steve French50c2f752007-07-13 00:33:32 +00003415 bcc_ptr += length + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003416 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3417 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3418 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3419 if ((bcc_ptr + (2 * length)) -
3420 pByteArea(smb_buffer_response) <=
3421 BCC(smb_buffer_response)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08003422 kfree(tcon->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 tcon->nativeFileSystem =
Pekka Enberge915fc42005-09-06 15:18:35 -07003424 kzalloc(length + 2, GFP_KERNEL);
Steve French88f370a2007-09-15 03:01:17 +00003425 if (tcon->nativeFileSystem)
3426 cifs_strfromUCS_le(
3427 tcon->nativeFileSystem,
3428 (__le16 *) bcc_ptr,
3429 length, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430 bcc_ptr += 2 * length;
3431 bcc_ptr[0] = 0; /* null terminate the string */
3432 bcc_ptr[1] = 0;
3433 bcc_ptr += 2;
3434 }
Steve French50c2f752007-07-13 00:33:32 +00003435 /* else do not bother copying these information fields*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003436 } else {
3437 length = strnlen(bcc_ptr, 1024);
3438 if ((bcc_ptr + length) -
3439 pByteArea(smb_buffer_response) <=
3440 BCC(smb_buffer_response)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08003441 kfree(tcon->nativeFileSystem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442 tcon->nativeFileSystem =
Pekka Enberge915fc42005-09-06 15:18:35 -07003443 kzalloc(length + 1, GFP_KERNEL);
Steve French88f370a2007-09-15 03:01:17 +00003444 if (tcon->nativeFileSystem)
3445 strncpy(tcon->nativeFileSystem, bcc_ptr,
3446 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003447 }
Steve French50c2f752007-07-13 00:33:32 +00003448 /* else do not bother copying these information fields*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003450 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003451 (smb_buffer_response->WordCount == 7))
3452 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003453 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3454 else
3455 tcon->Flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003456 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3457 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003458 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 ses->ipc_tid = smb_buffer_response->Tid;
3460 }
3461
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003462 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 return rc;
3464}
3465
3466int
3467cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3468{
3469 int rc = 0;
3470 int xid;
3471 struct cifsSesInfo *ses = NULL;
3472 struct task_struct *cifsd_task;
Steve French50c2f752007-07-13 00:33:32 +00003473 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474
3475 xid = GetXid();
3476
3477 if (cifs_sb->tcon) {
3478 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3479 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3480 if (rc == -EBUSY) {
3481 FreeXid(xid);
3482 return 0;
3483 }
3484 tconInfoFree(cifs_sb->tcon);
3485 if ((ses) && (ses->server)) {
3486 /* save off task so we do not refer to ses later */
3487 cifsd_task = ses->server->tsk;
3488 cFYI(1, ("About to do SMBLogoff "));
3489 rc = CIFSSMBLogoff(xid, ses);
3490 if (rc == -EBUSY) {
3491 FreeXid(xid);
3492 return 0;
3493 } else if (rc == -ESHUTDOWN) {
Steve French467a8f82007-06-27 22:41:32 +00003494 cFYI(1, ("Waking up socket by sending signal"));
Steve Frenchf7f7c312007-05-24 02:29:51 +00003495 if (cifsd_task) {
Steve French50c2f752007-07-13 00:33:32 +00003496 force_sig(SIGKILL, cifsd_task);
Igor Mammedovaaf737a2007-04-03 19:16:43 +00003497 kthread_stop(cifsd_task);
Steve Frenchf1914012005-08-18 09:37:34 -07003498 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 rc = 0;
3500 } /* else - we have an smb session
3501 left on this socket do not kill cifsd */
3502 } else
3503 cFYI(1, ("No session or bad tcon"));
3504 }
Steve French50c2f752007-07-13 00:33:32 +00003505
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 cifs_sb->tcon = NULL;
Steve French2fe87f02006-09-21 07:02:52 +00003507 tmp = cifs_sb->prepath;
3508 cifs_sb->prepathlen = 0;
3509 cifs_sb->prepath = NULL;
3510 kfree(tmp);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -07003511 if (ses)
3512 schedule_timeout_interruptible(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513 if (ses)
3514 sesInfoFree(ses);
3515
3516 FreeXid(xid);
Steve French50c2f752007-07-13 00:33:32 +00003517 return rc; /* BB check if we should always return zero here */
3518}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519
3520int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
Steve French50c2f752007-07-13 00:33:32 +00003521 struct nls_table *nls_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522{
3523 int rc = 0;
Steve French7c7b25b2006-06-01 19:20:10 +00003524 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525 int ntlmv2_flag = FALSE;
Steve Frenchad009ac2005-04-28 22:41:05 -07003526 int first_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527
3528 /* what if server changes its buffer size after dropping the session? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003529 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003531 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve French50c2f752007-07-13 00:33:32 +00003533 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003534 rc = -EHOSTDOWN;
3535 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003536 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003537 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003538 if (pSesInfo->server->tcpStatus != CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539 pSesInfo->server->tcpStatus = CifsGood;
3540 else
3541 rc = -EHOSTDOWN;
3542 spin_unlock(&GlobalMid_Lock);
3543
3544 }
Steve Frenchad009ac2005-04-28 22:41:05 -07003545 first_time = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 }
3547 if (!rc) {
Steve French9ac00b72006-09-30 04:13:17 +00003548 pSesInfo->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 pSesInfo->capabilities = pSesInfo->server->capabilities;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003550 if (linuxExtEnabled == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551 pSesInfo->capabilities &= (~CAP_UNIX);
Steve Frenchad009ac2005-04-28 22:41:05 -07003552 /* pSesInfo->sequence_number = 0;*/
Steve French50c2f752007-07-13 00:33:32 +00003553 cFYI(1,
3554 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555 pSesInfo->server->secMode,
3556 pSesInfo->server->capabilities,
Steve French175ec9e2006-09-30 01:07:38 +00003557 pSesInfo->server->timeAdj));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003558 if (experimEnabled < 2)
Steve French39798772006-05-31 22:40:51 +00003559 rc = CIFS_SessSetup(xid, pSesInfo,
3560 first_time, nls_info);
Steve French189acaa2006-06-23 02:33:48 +00003561 else if (extended_security
Steve French50c2f752007-07-13 00:33:32 +00003562 && (pSesInfo->capabilities
Steve French175ec9e2006-09-30 01:07:38 +00003563 & CAP_EXTENDED_SECURITY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564 && (pSesInfo->server->secType == NTLMSSP)) {
Steve French189acaa2006-06-23 02:33:48 +00003565 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566 } else if (extended_security
3567 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3568 && (pSesInfo->server->secType == RawNTLMSSP)) {
Steve French5815449d2006-02-14 01:36:20 +00003569 cFYI(1, ("NTLMSSP sesssetup"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003570 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3571 pSesInfo,
3572 &ntlmv2_flag,
3573 nls_info);
3574 if (!rc) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003575 if (ntlmv2_flag) {
Steve French50c2f752007-07-13 00:33:32 +00003576 char *v2_response;
Steve French467a8f82007-06-27 22:41:32 +00003577 cFYI(1, ("more secure NTLM ver2 hash"));
Steve French50c2f752007-07-13 00:33:32 +00003578 if (CalcNTLMv2_partial_mac_key(pSesInfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 nls_info)) {
3580 rc = -ENOMEM;
3581 goto ss_err_exit;
3582 } else
3583 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003584 if (v2_response) {
Steve French50c2f752007-07-13 00:33:32 +00003585 CalcNTLMv2_response(pSesInfo,
3586 v2_response);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003587 /* if (first_time)
Steve French50c2f752007-07-13 00:33:32 +00003588 cifs_calculate_ntlmv2_mac_key(
3589 pSesInfo->server->mac_signing_key,
3590 response, ntlm_session_key,*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591 kfree(v2_response);
3592 /* BB Put dummy sig in SessSetup PDU? */
3593 } else {
3594 rc = -ENOMEM;
3595 goto ss_err_exit;
3596 }
3597
3598 } else {
3599 SMBNTencrypt(pSesInfo->password,
3600 pSesInfo->server->cryptKey,
3601 ntlm_session_key);
3602
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003603 if (first_time)
Steve Frenchad009ac2005-04-28 22:41:05 -07003604 cifs_calculate_mac_key(
Steve Frenchb609f062007-07-09 07:55:14 +00003605 &pSesInfo->server->mac_signing_key,
Steve Frenchad009ac2005-04-28 22:41:05 -07003606 ntlm_session_key,
3607 pSesInfo->password);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 }
3609 /* for better security the weaker lanman hash not sent
3610 in AuthSessSetup so we no longer calculate it */
3611
3612 rc = CIFSNTLMSSPAuthSessSetup(xid,
3613 pSesInfo,
3614 ntlm_session_key,
3615 ntlmv2_flag,
3616 nls_info);
3617 }
3618 } else { /* old style NTLM 0.12 session setup */
3619 SMBNTencrypt(pSesInfo->password,
3620 pSesInfo->server->cryptKey,
3621 ntlm_session_key);
3622
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003623 if (first_time)
Steve Frenchad009ac2005-04-28 22:41:05 -07003624 cifs_calculate_mac_key(
Steve Frenchb609f062007-07-09 07:55:14 +00003625 &pSesInfo->server->mac_signing_key,
Steve Frenchad009ac2005-04-28 22:41:05 -07003626 ntlm_session_key, pSesInfo->password);
3627
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628 rc = CIFSSessSetup(xid, pSesInfo,
3629 ntlm_session_key, nls_info);
3630 }
3631 if (rc) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003632 cERROR(1, ("Send error in SessSetup = %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633 } else {
Steve French467a8f82007-06-27 22:41:32 +00003634 cFYI(1, ("CIFS Session Established successfully"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003635 pSesInfo->status = CifsGood;
3636 }
3637 }
3638ss_err_exit:
3639 return rc;
3640}
3641