blob: 3fb799ff55c9fbcdf5c4243a32bee3b65f3c7bdf [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve Frenchd185cda2009-04-30 17:45:10 +00004 * Copyright (C) International Business Machines Corp., 2002,2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/pagemap.h>
27#include <linux/ctype.h>
28#include <linux/utsname.h>
29#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070030#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070031#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000032#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070033#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080034#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040035#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
37#include <asm/processor.h>
Jeff Layton50b64e32009-06-02 06:55:20 -040038#include <linux/inet.h>
Steve French0e2beda2009-01-30 21:24:41 +000039#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "cifspdu.h"
41#include "cifsglob.h"
42#include "cifsproto.h"
43#include "cifs_unicode.h"
44#include "cifs_debug.h"
45#include "cifs_fs_sb.h"
46#include "ntlmssp.h"
47#include "nterr.h"
48#include "rfc1002pdu.h"
Steve Frencha2653eb2005-11-10 15:33:38 -080049#include "cn_cifs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51#define CIFS_PORT 445
52#define RFC1001_PORT 139
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 unsigned char *p24);
56
57extern mempool_t *cifs_req_poolp;
58
59struct smb_vol {
60 char *username;
61 char *password;
62 char *domainname;
63 char *UNC;
64 char *UNCip;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 char *iocharset; /* local code page for mapping to and from Unicode */
66 char source_rfc1001_name[16]; /* netbios name of client */
Steve Frencha10faeb22005-08-22 21:38:31 -070067 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 uid_t linux_uid;
69 gid_t linux_gid;
70 mode_t file_mode;
71 mode_t dir_mode;
Steve French189acaa2006-06-23 02:33:48 +000072 unsigned secFlg;
Steve French4b18f2a2008-04-29 00:06:05 +000073 bool rw:1;
74 bool retry:1;
75 bool intr:1;
76 bool setuids:1;
77 bool override_uid:1;
78 bool override_gid:1;
Jeff Laytond0a9c072008-05-12 22:23:49 +000079 bool dynperm:1;
Steve French4b18f2a2008-04-29 00:06:05 +000080 bool noperm:1;
81 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool cifs_acl:1;
83 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool direct_io:1;
Steve French95b1cb92008-05-15 16:44:38 +000086 bool remap:1; /* set to remap seven reserved chars in filenames */
87 bool posix_paths:1; /* unset to not ask for posix pathnames. */
Steve French4b18f2a2008-04-29 00:06:05 +000088 bool no_linux_ext:1;
89 bool sfu_emul:1;
Steve French95b1cb92008-05-15 16:44:38 +000090 bool nullauth:1; /* attempt to authenticate with null user */
91 bool nocase:1; /* request case insensitive filenames */
92 bool nobrl:1; /* disable sending byte range locks to srv */
Steve French13a6e422008-12-02 17:24:33 +000093 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
Steve French95b1cb92008-05-15 16:44:38 +000094 bool seal:1; /* request transport encryption on share */
Steve French84210e92008-10-23 04:42:37 +000095 bool nodfs:1; /* Do not request DFS, even if available */
96 bool local_lease:1; /* check leases only on local system, not remote */
Steve Frenchedf1ae42008-10-29 00:47:57 +000097 bool noblocksnd:1;
98 bool noautotune:1;
Steve Frenchbe652442009-02-23 15:21:59 +000099 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 unsigned int rsize;
101 unsigned int wsize;
102 unsigned int sockopt;
103 unsigned short int port;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000104 char *prepath;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105};
106
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500107static int ipv4_connect(struct TCP_Server_Info *server);
Jeff Laytond5c56052008-12-01 18:42:33 -0500108static int ipv6_connect(struct TCP_Server_Info *server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Jeff Laytond5c56052008-12-01 18:42:33 -0500110/*
111 * cifs tcp session reconnection
112 *
113 * mark tcp session as reconnecting so temporarily locked
114 * mark all smb sessions as reconnecting for tcp session
115 * reconnect tcp session
116 * wake up waiters on reconnection? - (not needed currently)
117 */
Steve French2cd646a2006-09-28 19:43:08 +0000118static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119cifs_reconnect(struct TCP_Server_Info *server)
120{
121 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500122 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 struct cifsSesInfo *ses;
124 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000125 struct mid_q_entry *mid_entry;
Steve French50c2f752007-07-13 00:33:32 +0000126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000128 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000129 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 next time through the loop */
131 spin_unlock(&GlobalMid_Lock);
132 return rc;
133 } else
134 server->tcpStatus = CifsNeedReconnect;
135 spin_unlock(&GlobalMid_Lock);
136 server->maxBuf = 0;
137
Steve Frenche4eb2952005-04-28 22:41:09 -0700138 cFYI(1, ("Reconnecting tcp session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140 /* before reconnecting the tcp session, mark the smb session (uid)
141 and the tid bad so they are not used until reconnected */
Jeff Layton14fbf502008-11-14 13:53:46 -0500142 read_lock(&cifs_tcp_ses_lock);
143 list_for_each(tmp, &server->smb_ses_list) {
144 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
145 ses->need_reconnect = true;
146 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500147 list_for_each(tmp2, &ses->tcon_list) {
148 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
149 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500152 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 /* do not want to be sending data on a socket we are freeing */
Jeff Layton72ca5452008-12-01 07:09:36 -0500154 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000155 if (server->ssocket) {
Steve French467a8f82007-06-27 22:41:32 +0000156 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 server->ssocket->flags));
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800158 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000159 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000160 server->ssocket->state,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 server->ssocket->flags));
162 sock_release(server->ssocket);
163 server->ssocket = NULL;
164 }
165
166 spin_lock(&GlobalMid_Lock);
167 list_for_each(tmp, &server->pending_mid_q) {
168 mid_entry = list_entry(tmp, struct
169 mid_q_entry,
170 qhead);
Steve Frenchad8b15f2008-08-08 21:10:16 +0000171 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French09d1db52005-04-28 22:41:08 -0700172 /* Mark other intransit requests as needing
173 retry so we do not immediately mark the
174 session bad again (ie after we reconnect
175 below) as they timeout too */
Steve Frenchad8b15f2008-08-08 21:10:16 +0000176 mid_entry->midState = MID_RETRY_NEEDED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 }
178 }
179 spin_unlock(&GlobalMid_Lock);
Jeff Layton72ca5452008-12-01 07:09:36 -0500180 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Jeff Layton469ee612008-10-16 18:46:39 +0000182 while ((server->tcpStatus != CifsExiting) &&
183 (server->tcpStatus != CifsGood)) {
Steve French6c3d8902006-07-31 22:46:20 +0000184 try_to_freeze();
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500185 if (server->addr.sockAddr6.sin6_family == AF_INET6)
Jeff Laytond5c56052008-12-01 18:42:33 -0500186 rc = ipv6_connect(server);
Jeff Laytonbcf4b102008-12-01 18:42:15 -0500187 else
188 rc = ipv4_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000189 if (rc) {
190 cFYI(1, ("reconnect error %d", rc));
Steve French0cb766a2005-04-28 22:41:11 -0700191 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 } else {
193 atomic_inc(&tcpSesReconnectCount);
194 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000195 if (server->tcpStatus != CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 server->tcpStatus = CifsGood;
Steve Frenchad009ac2005-04-28 22:41:05 -0700197 server->sequence_number = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000198 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 /* atomic_set(&server->inFlight,0);*/
200 wake_up(&server->response_q);
201 }
202 }
203 return rc;
204}
205
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000206/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700207 return codes:
208 0 not a transact2, or all data present
209 >0 transact2 with that much data missing
210 -EINVAL = invalid transact2
211
212 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000213static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700214{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000215 struct smb_t2_rsp *pSMBt;
216 int total_data_size;
Steve Frenche4eb2952005-04-28 22:41:09 -0700217 int data_in_this_rsp;
218 int remaining;
219
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000220 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700221 return 0;
222
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000223 /* check for plausible wct, bcc and t2 data and parm sizes */
224 /* check for parm and data offset going beyond end of smb */
225 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Steve French467a8f82007-06-27 22:41:32 +0000226 cFYI(1, ("invalid transact2 word count"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700227 return -EINVAL;
228 }
229
230 pSMBt = (struct smb_t2_rsp *)pSMB;
231
232 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
233 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
234
235 remaining = total_data_size - data_in_this_rsp;
236
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000237 if (remaining == 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700238 return 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000239 else if (remaining < 0) {
Steve French467a8f82007-06-27 22:41:32 +0000240 cFYI(1, ("total data %d smaller than data in frame %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700241 total_data_size, data_in_this_rsp));
242 return -EINVAL;
243 } else {
Steve French467a8f82007-06-27 22:41:32 +0000244 cFYI(1, ("missing %d bytes from transact2, check next response",
Steve Frenche4eb2952005-04-28 22:41:09 -0700245 remaining));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000246 if (total_data_size > maxBufSize) {
247 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
248 total_data_size, maxBufSize));
249 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700250 }
251 return remaining;
252 }
253}
254
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000255static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700256{
257 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
258 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
259 int total_data_size;
260 int total_in_buf;
261 int remaining;
262 int total_in_buf2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000263 char *data_area_of_target;
264 char *data_area_of_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700265 __u16 byte_count;
266
267 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
268
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000269 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
Steve French63135e02007-07-17 17:34:02 +0000270 cFYI(1, ("total data size of primary and secondary t2 differ"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700271 }
272
273 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
274
275 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000276
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000277 if (remaining < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700278 return -EINVAL;
279
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000280 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700281 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000282
Steve Frenche4eb2952005-04-28 22:41:09 -0700283 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000284 if (remaining < total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000285 cFYI(1, ("transact2 2nd response contains too much data"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700286 }
287
288 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000289 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Steve Frenche4eb2952005-04-28 22:41:09 -0700290 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
291 /* validate target area */
292
293 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000294 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700295
296 data_area_of_target += total_in_buf;
297
298 /* copy second buffer into end of first buffer */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000299 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
Steve Frenche4eb2952005-04-28 22:41:09 -0700300 total_in_buf += total_in_buf2;
301 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
302 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
303 byte_count += total_in_buf2;
304 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
305
Steve French70ca7342005-09-22 16:32:06 -0700306 byte_count = pTargetSMB->smb_buf_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700307 byte_count += total_in_buf2;
308
309 /* BB also add check that we are not beyond maximum buffer size */
Steve French50c2f752007-07-13 00:33:32 +0000310
Steve French70ca7342005-09-22 16:32:06 -0700311 pTargetSMB->smb_buf_length = byte_count;
Steve Frenche4eb2952005-04-28 22:41:09 -0700312
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000313 if (remaining == total_in_buf2) {
Steve French467a8f82007-06-27 22:41:32 +0000314 cFYI(1, ("found the last secondary response"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700315 return 0; /* we are done */
316 } else /* more responses to go */
317 return 1;
318
319}
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321static int
322cifs_demultiplex_thread(struct TCP_Server_Info *server)
323{
324 int length;
325 unsigned int pdu_length, total_read;
326 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700327 struct smb_hdr *bigbuf = NULL;
328 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 struct msghdr smb_msg;
330 struct kvec iov;
331 struct socket *csocket = server->ssocket;
332 struct list_head *tmp;
333 struct cifsSesInfo *ses;
334 struct task_struct *task_to_wake = NULL;
335 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700336 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000337 bool isLargeBuf = false;
338 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700339 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 current->flags |= PF_MEMALLOC;
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700342 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400343
344 length = atomic_inc_return(&tcpSesAllocCount);
345 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000346 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
347 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700349 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000350 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700351 if (try_to_freeze())
352 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700353 if (bigbuf == NULL) {
354 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000355 if (!bigbuf) {
356 cERROR(1, ("No memory for large SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700357 msleep(3000);
358 /* retry will check if exiting */
359 continue;
360 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000361 } else if (isLargeBuf) {
362 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000363 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700365
366 if (smallbuf == NULL) {
367 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000368 if (!smallbuf) {
369 cERROR(1, ("No memory for SMB response"));
Steve Frenchb8643e12005-04-28 22:41:07 -0700370 msleep(1000);
371 /* retry will check if exiting */
372 continue;
373 }
374 /* beginning of smb buffer is cleared in our buf_get */
375 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000376 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700377
Steve French4b18f2a2008-04-29 00:06:05 +0000378 isLargeBuf = false;
379 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700380 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 iov.iov_base = smb_buffer;
382 iov.iov_len = 4;
383 smb_msg.msg_control = NULL;
384 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000385 pdu_length = 4; /* enough to get RFC1001 header */
386incomplete_rcv:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 length =
388 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000389 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Jeff Layton469ee612008-10-16 18:46:39 +0000391 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 break;
393 } else if (server->tcpStatus == CifsNeedReconnect) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000394 cFYI(1, ("Reconnect after server stopped responding"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 cifs_reconnect(server);
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000396 cFYI(1, ("call to reconnect done"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 csocket = server->ssocket;
398 continue;
399 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700400 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 allowing socket to clear and app threads to set
402 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000403 if (pdu_length < 4) {
404 iov.iov_base = (4 - pdu_length) +
405 (char *)smb_buffer;
406 iov.iov_len = pdu_length;
407 smb_msg.msg_control = NULL;
408 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000409 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000410 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000411 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 } else if (length <= 0) {
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000413 if (server->tcpStatus == CifsNew) {
414 cFYI(1, ("tcp session abend after SMBnegprot"));
Steve French09d1db52005-04-28 22:41:08 -0700415 /* some servers kill the TCP session rather than
416 returning an SMB negprot error, in which
417 case reconnecting here is not going to help,
418 and so simply return error to mount */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 break;
420 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000421 if (!try_to_freeze() && (length == -EINTR)) {
Steve French467a8f82007-06-27 22:41:32 +0000422 cFYI(1, ("cifsd thread killed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 break;
424 }
Steve French467a8f82007-06-27 22:41:32 +0000425 cFYI(1, ("Reconnect after unexpected peek error %d",
Steve French57337e42005-04-28 22:41:10 -0700426 length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 cifs_reconnect(server);
428 csocket = server->ssocket;
429 wake_up(&server->response_q);
430 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000431 } else if (length < pdu_length) {
432 cFYI(1, ("requested %d bytes but only got %d bytes",
433 pdu_length, length));
Steve Frenchf01d5e12007-08-30 21:13:31 +0000434 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000435 msleep(1);
436 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
Steve French67010fb2005-04-28 22:41:09 -0700438
Steve French70ca7342005-09-22 16:32:06 -0700439 /* The right amount was read from socket - 4 bytes */
440 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700441
Steve French70ca7342005-09-22 16:32:06 -0700442 /* the first byte big endian of the length field,
443 is actually not part of the length but the type
444 with the most common, zero, as regular data */
445 temp = *((char *) smb_buffer);
446
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000447 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700448 but we convert it here so it is always manipulated
449 as host byte order */
Harvey Harrison5ca33c62008-07-23 17:45:58 -0700450 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
Steve French70ca7342005-09-22 16:32:06 -0700451 smb_buffer->smb_buf_length = pdu_length;
Steve French46810cb2005-04-28 22:41:09 -0700452
Steve French467a8f82007-06-27 22:41:32 +0000453 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
Steve French70ca7342005-09-22 16:32:06 -0700454
455 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000456 continue;
Steve French70ca7342005-09-22 16:32:06 -0700457 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
Steve French467a8f82007-06-27 22:41:32 +0000458 cFYI(1, ("Good RFC 1002 session rsp"));
Steve Frenche4eb2952005-04-28 22:41:09 -0700459 continue;
Steve French70ca7342005-09-22 16:32:06 -0700460 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000461 /* we get this from Windows 98 instead of
Steve French46810cb2005-04-28 22:41:09 -0700462 an error on SMB negprot response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000463 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
Steve French70ca7342005-09-22 16:32:06 -0700464 pdu_length));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000465 if (server->tcpStatus == CifsNew) {
466 /* if nack on negprot (rather than
Steve French46810cb2005-04-28 22:41:09 -0700467 ret of smb negprot error) reconnecting
468 not going to help, ret error to mount */
469 break;
470 } else {
471 /* give server a second to
472 clean up before reconnect attempt */
473 msleep(1000);
474 /* always try 445 first on reconnect
475 since we get NACK on some if we ever
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000476 connected to port 139 (the NACK is
Steve French46810cb2005-04-28 22:41:09 -0700477 since we do not begin with RFC1001
478 session initialize frame) */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000479 server->addr.sockAddr.sin_port =
Steve French46810cb2005-04-28 22:41:09 -0700480 htons(CIFS_PORT);
481 cifs_reconnect(server);
482 csocket = server->ssocket;
483 wake_up(&server->response_q);
484 continue;
485 }
Steve French70ca7342005-09-22 16:32:06 -0700486 } else if (temp != (char) 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000487 cERROR(1, ("Unknown RFC 1002 frame"));
Steve French70ca7342005-09-22 16:32:06 -0700488 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
489 length);
Steve French46810cb2005-04-28 22:41:09 -0700490 cifs_reconnect(server);
491 csocket = server->ssocket;
492 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700493 }
494
495 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000496 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000497 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700498 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
Steve French46810cb2005-04-28 22:41:09 -0700499 length, pdu_length+4));
Steve Frenche4eb2952005-04-28 22:41:09 -0700500 cifs_reconnect(server);
501 csocket = server->ssocket;
502 wake_up(&server->response_q);
503 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000504 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700505
506 /* else length ok */
507 reconnect = 0;
508
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000509 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000510 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700511 memcpy(bigbuf, smallbuf, 4);
512 smb_buffer = bigbuf;
513 }
514 length = 0;
515 iov.iov_base = 4 + (char *)smb_buffer;
516 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000517 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700518 total_read += length) {
519 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
520 pdu_length - total_read, 0);
Jeff Layton469ee612008-10-16 18:46:39 +0000521 if ((server->tcpStatus == CifsExiting) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700522 (length == -EINTR)) {
523 /* then will exit */
524 reconnect = 2;
525 break;
526 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700527 cifs_reconnect(server);
528 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000529 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700530 /* Now we will reread sock */
531 reconnect = 1;
532 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000533 } else if ((length == -ERESTARTSYS) ||
Steve Frenche4eb2952005-04-28 22:41:09 -0700534 (length == -EAGAIN)) {
535 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000536 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700537 threads to set tcpStatus
538 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000539 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700540 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700541 } else if (length <= 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000542 cERROR(1, ("Received no data, expecting %d",
Steve Frenche4eb2952005-04-28 22:41:09 -0700543 pdu_length - total_read));
544 cifs_reconnect(server);
545 csocket = server->ssocket;
546 reconnect = 1;
547 break;
Steve French46810cb2005-04-28 22:41:09 -0700548 }
549 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000550 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700551 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000552 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700553 continue;
554
555 length += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000556
Steve Frenche4eb2952005-04-28 22:41:09 -0700557
558 dump_smb(smb_buffer, length);
Steve French184ed212006-02-24 06:15:11 +0000559 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
Steve Frenchb387eae2005-10-10 14:21:15 -0700560 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
Steve Frenche4eb2952005-04-28 22:41:09 -0700561 continue;
562 }
563
564
565 task_to_wake = NULL;
566 spin_lock(&GlobalMid_Lock);
567 list_for_each(tmp, &server->pending_mid_q) {
568 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
569
Steve French50c2f752007-07-13 00:33:32 +0000570 if ((mid_entry->mid == smb_buffer->Mid) &&
Steve Frenche4eb2952005-04-28 22:41:09 -0700571 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
572 (mid_entry->command == smb_buffer->Command)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000573 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700574 /* We have a multipart transact2 resp */
Steve French4b18f2a2008-04-29 00:06:05 +0000575 isMultiRsp = true;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000576 if (mid_entry->resp_buf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700577 /* merge response - fix up 1st*/
Steve French50c2f752007-07-13 00:33:32 +0000578 if (coalesce_t2(smb_buffer,
Steve Frenche4eb2952005-04-28 22:41:09 -0700579 mid_entry->resp_buf)) {
Steve French4b18f2a2008-04-29 00:06:05 +0000580 mid_entry->multiRsp =
581 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700582 break;
583 } else {
584 /* all parts received */
Steve French4b18f2a2008-04-29 00:06:05 +0000585 mid_entry->multiEnd =
586 true;
Steve French50c2f752007-07-13 00:33:32 +0000587 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700588 }
589 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000590 if (!isLargeBuf) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700591 cERROR(1,("1st trans2 resp needs bigbuf"));
592 /* BB maybe we can fix this up, switch
Steve French50c2f752007-07-13 00:33:32 +0000593 to already allocated large buffer? */
Steve Frenche4eb2952005-04-28 22:41:09 -0700594 } else {
Steve Frenchcd634992005-04-28 22:41:10 -0700595 /* Have first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700596 mid_entry->resp_buf =
597 smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000598 mid_entry->largeBuf =
599 true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700600 bigbuf = NULL;
601 }
602 }
603 break;
Steve French50c2f752007-07-13 00:33:32 +0000604 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700605 mid_entry->resp_buf = smb_buffer;
Steve French4b18f2a2008-04-29 00:06:05 +0000606 mid_entry->largeBuf = isLargeBuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700607multi_t2_fnd:
608 task_to_wake = mid_entry->tsk;
609 mid_entry->midState = MID_RESPONSE_RECEIVED;
Steve French1047abc2005-10-11 19:58:06 -0700610#ifdef CONFIG_CIFS_STATS2
611 mid_entry->when_received = jiffies;
612#endif
Steve French3a5ff612006-07-14 22:37:11 +0000613 /* so we do not time out requests to server
614 which is still responding (since server could
615 be busy but not dead) */
616 server->lstrp = jiffies;
Steve Frenche4eb2952005-04-28 22:41:09 -0700617 break;
618 }
619 }
620 spin_unlock(&GlobalMid_Lock);
621 if (task_to_wake) {
Steve Frenchcd634992005-04-28 22:41:10 -0700622 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000623 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700624 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000625 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700626 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000627 else
Steve Frenchcd634992005-04-28 22:41:10 -0700628 smallbuf = NULL;
629 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700630 wake_up_process(task_to_wake);
Steve French4b18f2a2008-04-29 00:06:05 +0000631 } else if (!is_valid_oplock_break(smb_buffer, server) &&
632 !isMultiRsp) {
Steve French50c2f752007-07-13 00:33:32 +0000633 cERROR(1, ("No task to wake, unknown frame received! "
634 "NumMids %d", midCount.counter));
635 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700636 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000637#ifdef CONFIG_CIFS_DEBUG2
638 cifs_dump_detail(smb_buffer);
639 cifs_dump_mids(server);
640#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000641
Steve Frenche4eb2952005-04-28 22:41:09 -0700642 }
643 } /* end while !EXITING */
644
Jeff Laytone7ddee92008-11-14 13:44:38 -0500645 /* take it off the list, if it's not already */
646 write_lock(&cifs_tcp_ses_lock);
647 list_del_init(&server->tcp_ses_list);
648 write_unlock(&cifs_tcp_ses_lock);
649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 spin_lock(&GlobalMid_Lock);
651 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000652 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000653 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000654
Steve French31ca3bc2005-04-28 22:41:11 -0700655 /* check if we have blocked requests that need to free */
656 /* Note that cifs_max_pending is normally 50, but
657 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000658 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000659 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700660 atomic_set(&server->inFlight, cifs_max_pending - 1);
661 /* We do not want to set the max_pending too low or we
662 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000664 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700666 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 to the same server - they now will see the session is in exit state
668 and get out of SendReceive. */
669 wake_up_all(&server->request_q);
670 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700671 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000672
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000673 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 sock_release(csocket);
675 server->ssocket = NULL;
676 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700677 /* buffer usuallly freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000678 cifs_buf_release(bigbuf);
679 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700680 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Jeff Layton14fbf502008-11-14 13:53:46 -0500682 /*
683 * BB: we shouldn't have to do any of this. It shouldn't be
684 * possible to exit from the thread with active SMB sessions
685 */
686 read_lock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 if (list_empty(&server->pending_mid_q)) {
Steve French09d1db52005-04-28 22:41:08 -0700688 /* loop through server session structures attached to this and
689 mark them dead */
Jeff Layton14fbf502008-11-14 13:53:46 -0500690 list_for_each(tmp, &server->smb_ses_list) {
691 ses = list_entry(tmp, struct cifsSesInfo,
692 smb_ses_list);
693 ses->status = CifsExiting;
694 ses->server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500696 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 } else {
Steve French31ca3bc2005-04-28 22:41:11 -0700698 /* although we can not zero the server struct pointer yet,
699 since there are active requests which may depnd on them,
700 mark the corresponding SMB sessions as exiting too */
Jeff Layton14fbf502008-11-14 13:53:46 -0500701 list_for_each(tmp, &server->smb_ses_list) {
Steve French31ca3bc2005-04-28 22:41:11 -0700702 ses = list_entry(tmp, struct cifsSesInfo,
Jeff Layton14fbf502008-11-14 13:53:46 -0500703 smb_ses_list);
704 ses->status = CifsExiting;
Steve French31ca3bc2005-04-28 22:41:11 -0700705 }
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 spin_lock(&GlobalMid_Lock);
708 list_for_each(tmp, &server->pending_mid_q) {
709 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
710 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
Steve French50c2f752007-07-13 00:33:32 +0000711 cFYI(1, ("Clearing Mid 0x%x - waking up ",
712 mid_entry->mid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 task_to_wake = mid_entry->tsk;
Steve French26f57362007-08-30 22:09:15 +0000714 if (task_to_wake)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 wake_up_process(task_to_wake);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
717 }
718 spin_unlock(&GlobalMid_Lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500719 read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700721 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 }
723
Steve Frenchf1914012005-08-18 09:37:34 -0700724 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000725 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700727 /* due to delays on oplock break requests, we need
728 to wait at least 45 seconds before giving up
729 on a request getting a response and going ahead
730 and killing cifsd */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 cFYI(1, ("Wait for exit from demultiplex thread"));
Steve French31ca3bc2005-04-28 22:41:11 -0700732 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 /* if threads still have not exited they are probably never
734 coming home not much else we can do but free the memory */
735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Steve French31ca3bc2005-04-28 22:41:11 -0700737 /* last chance to mark ses pointers invalid
738 if there are any pointing to this (e.g
Steve French50c2f752007-07-13 00:33:32 +0000739 if a crazy root user tried to kill cifsd
Steve French31ca3bc2005-04-28 22:41:11 -0700740 kernel thread explicitly this might happen) */
Jeff Layton14fbf502008-11-14 13:53:46 -0500741 /* BB: This shouldn't be necessary, see above */
742 read_lock(&cifs_tcp_ses_lock);
743 list_for_each(tmp, &server->smb_ses_list) {
744 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
745 ses->server = NULL;
Steve French31ca3bc2005-04-28 22:41:11 -0700746 }
Jeff Layton14fbf502008-11-14 13:53:46 -0500747 read_unlock(&cifs_tcp_ses_lock);
Steve French31ca3bc2005-04-28 22:41:11 -0700748
Jeff Laytonc359cf32007-11-16 22:22:06 +0000749 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400750 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700751 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400752
753 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000754 if (length > 0)
755 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
756 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000757
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400758 /* if server->tsk was NULL then wait for a signal before exiting */
759 if (!task_to_wake) {
760 set_current_state(TASK_INTERRUPTIBLE);
761 while (!signal_pending(current)) {
762 schedule();
763 set_current_state(TASK_INTERRUPTIBLE);
764 }
765 set_current_state(TASK_RUNNING);
766 }
767
Jeff Layton0468a2c2008-12-01 07:09:35 -0500768 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769}
770
Jeff Laytonc359cf32007-11-16 22:22:06 +0000771/* extract the host portion of the UNC string */
772static char *
773extract_hostname(const char *unc)
774{
775 const char *src;
776 char *dst, *delim;
777 unsigned int len;
778
779 /* skip double chars at beginning of string */
780 /* BB: check validity of these bytes? */
781 src = unc + 2;
782
783 /* delimiter between hostname and sharename is always '\\' now */
784 delim = strchr(src, '\\');
785 if (!delim)
786 return ERR_PTR(-EINVAL);
787
788 len = delim - src;
789 dst = kmalloc((len + 1), GFP_KERNEL);
790 if (dst == NULL)
791 return ERR_PTR(-ENOMEM);
792
793 memcpy(dst, src, len);
794 dst[len] = '\0';
795
796 return dst;
797}
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799static int
Steve French50c2f752007-07-13 00:33:32 +0000800cifs_parse_mount_options(char *options, const char *devname,
801 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
803 char *value;
804 char *data;
805 unsigned int temp_len, i, j;
806 char separator[2];
807
808 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000809 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Linus Torvalds12e36b22006-10-13 08:09:29 -0700811 if (Local_System_Name[0] != 0)
Steve French50c2f752007-07-13 00:33:32 +0000812 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
Steve French2cd646a2006-09-28 19:43:08 +0000813 else {
Linus Torvalds12e36b22006-10-13 08:09:29 -0700814 char *nodename = utsname()->nodename;
Steve French50c2f752007-07-13 00:33:32 +0000815 int n = strnlen(nodename, 15);
816 memset(vol->source_rfc1001_name, 0x20, 15);
817 for (i = 0; i < n; i++) {
Steve French2cd646a2006-09-28 19:43:08 +0000818 /* does not have to be perfect mapping since field is
819 informational, only used for servers that do not support
820 port 445 and it can be overridden at mount time */
Linus Torvalds12e36b22006-10-13 08:09:29 -0700821 vol->source_rfc1001_name[i] = toupper(nodename[i]);
Steve French2cd646a2006-09-28 19:43:08 +0000822 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
824 vol->source_rfc1001_name[15] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700825 /* null target name indicates to use *SMBSERVR default called name
826 if we end up sending RFC1001 session initialize */
827 vol->target_rfc1001_name[0] = 0;
David Howellsa001e5b2008-11-14 10:38:47 +1100828 vol->linux_uid = current_uid(); /* use current_euid() instead? */
829 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400830
831 /* default to only allowing write access to owner of the mount */
832 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Steve French4b18f2a2008-04-29 00:06:05 +0000835 vol->rw = true;
Jeremy Allisonac670552005-06-22 17:26:35 -0700836 /* default is always to request posix paths. */
837 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400838 /* default to using server inode numbers where available */
839 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (!options)
842 return 1;
843
Steve French50c2f752007-07-13 00:33:32 +0000844 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000845 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 separator[0] = options[4];
847 options += 5;
848 } else {
Steve French467a8f82007-06-27 22:41:32 +0000849 cFYI(1, ("Null separator not allowed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 }
851 }
Steve French50c2f752007-07-13 00:33:32 +0000852
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 while ((data = strsep(&options, separator)) != NULL) {
854 if (!*data)
855 continue;
856 if ((value = strchr(data, '=')) != NULL)
857 *value++ = '\0';
858
Steve French50c2f752007-07-13 00:33:32 +0000859 /* Have to parse this before we parse for "user" */
860 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000862 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 vol->no_xattr = 1;
864 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000865 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 printk(KERN_WARNING
867 "CIFS: invalid or missing username\n");
868 return 1; /* needs_arg; */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000869 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000870 /* null user, ie anonymous, authentication */
871 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 }
873 if (strnlen(value, 200) < 200) {
874 vol->username = value;
875 } else {
876 printk(KERN_WARNING "CIFS: username too long\n");
877 return 1;
878 }
879 } else if (strnicmp(data, "pass", 4) == 0) {
880 if (!value) {
881 vol->password = NULL;
882 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000883 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 /* check if string begins with double comma
885 since that would mean the password really
886 does start with a comma, and would not
887 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000888 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 vol->password = NULL;
890 continue;
891 }
892 }
893 temp_len = strlen(value);
894 /* removed password length check, NTLM passwords
895 can be arbitrarily long */
896
Steve French50c2f752007-07-13 00:33:32 +0000897 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 prematurely null terminated. Commas in password are
899 specified across the cifs mount interface by a double
900 comma ie ,, and a comma used as in other cases ie ','
901 as a parameter delimiter/separator is single and due
902 to the strsep above is temporarily zeroed. */
903
904 /* NB: password legally can have multiple commas and
905 the only illegal character in a password is null */
906
Steve French50c2f752007-07-13 00:33:32 +0000907 if ((value[temp_len] == 0) &&
Steve French09d1db52005-04-28 22:41:08 -0700908 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 /* reinsert comma */
910 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000911 temp_len += 2; /* move after second comma */
912 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000914 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700915 separator[0]) {
916 /* skip second comma */
917 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000918 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 /* single comma indicating start
920 of next parm */
921 break;
922 }
923 }
924 temp_len++;
925 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000926 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 options = NULL;
928 } else {
929 value[temp_len] = 0;
930 /* point option to start of next parm */
931 options = value + temp_len + 1;
932 }
Steve French50c2f752007-07-13 00:33:32 +0000933 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 double commas to singles. Note that this ends up
935 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700936 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000937 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000938 printk(KERN_WARNING "CIFS: no memory "
939 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700940 return 1;
941 }
Steve French50c2f752007-07-13 00:33:32 +0000942 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000944 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700945 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 /* skip second comma */
947 i++;
948 }
949 }
950 vol->password[j] = 0;
951 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700952 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000953 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000954 printk(KERN_WARNING "CIFS: no memory "
955 "for password\n");
Steve French433dc242005-04-28 22:41:08 -0700956 return 1;
957 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 strcpy(vol->password, value);
959 }
Jeff Layton58f7f682009-06-10 09:57:55 -0400960 } else if (!strnicmp(data, "ip", 2) ||
961 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 if (!value || !*value) {
963 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -0400964 } else if (strnlen(value, INET6_ADDRSTRLEN) <
965 INET6_ADDRSTRLEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 vol->UNCip = value;
967 } else {
Steve French50c2f752007-07-13 00:33:32 +0000968 printk(KERN_WARNING "CIFS: ip address "
969 "too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 return 1;
971 }
Steve French50c2f752007-07-13 00:33:32 +0000972 } else if (strnicmp(data, "sec", 3) == 0) {
973 if (!value || !*value) {
974 cERROR(1, ("no security value specified"));
975 continue;
976 } else if (strnicmp(value, "krb5i", 5) == 0) {
977 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000978 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800979 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000980 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
981 CIFSSEC_MAY_KRB5; */
982 cERROR(1, ("Krb5 cifs privacy not supported"));
Steve Frenchbf820672005-12-01 22:32:42 -0800983 return 1;
984 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000985 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +0000986#ifdef CONFIG_CIFS_EXPERIMENTAL
987 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
989 CIFSSEC_MUST_SIGN;
990 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
991 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
992#endif
Steve Frenchbf820672005-12-01 22:32:42 -0800993 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000994 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000995 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800996 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000997 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -0800998 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000999 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +00001000 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001001 } else if (strnicmp(value, "ntlm", 4) == 0) {
1002 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001003 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001004 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001005 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001006 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001007#ifdef CONFIG_CIFS_WEAK_PW_HASH
1008 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001009 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001010#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001011 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001012 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001013 } else {
1014 cERROR(1, ("bad security option: %s", value));
1015 return 1;
1016 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 } else if ((strnicmp(data, "unc", 3) == 0)
1018 || (strnicmp(data, "target", 6) == 0)
1019 || (strnicmp(data, "path", 4) == 0)) {
1020 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001021 printk(KERN_WARNING "CIFS: invalid path to "
1022 "network resource\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 return 1; /* needs_arg; */
1024 }
1025 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001026 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001027 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001029 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (strncmp(vol->UNC, "//", 2) == 0) {
1031 vol->UNC[0] = '\\';
1032 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001033 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001035 "CIFS: UNC Path does not begin "
1036 "with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 return 1;
1038 }
1039 } else {
1040 printk(KERN_WARNING "CIFS: UNC name too long\n");
1041 return 1;
1042 }
1043 } else if ((strnicmp(data, "domain", 3) == 0)
1044 || (strnicmp(data, "workgroup", 5) == 0)) {
1045 if (!value || !*value) {
1046 printk(KERN_WARNING "CIFS: invalid domain name\n");
1047 return 1; /* needs_arg; */
1048 }
1049 /* BB are there cases in which a comma can be valid in
1050 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001051 if (strnlen(value, 256) < 256) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 vol->domainname = value;
1053 cFYI(1, ("Domain name set"));
1054 } else {
Steve French50c2f752007-07-13 00:33:32 +00001055 printk(KERN_WARNING "CIFS: domain name too "
1056 "long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 return 1;
1058 }
Steve French50c2f752007-07-13 00:33:32 +00001059 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1060 if (!value || !*value) {
1061 printk(KERN_WARNING
1062 "CIFS: invalid path prefix\n");
1063 return 1; /* needs_argument */
1064 }
1065 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001066 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001067 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001068 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1069 if (vol->prepath == NULL)
1070 return 1;
Steve French4523cc32007-04-30 20:13:06 +00001071 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001072 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001073 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001074 } else
Steve French50c2f752007-07-13 00:33:32 +00001075 strcpy(vol->prepath, value);
1076 cFYI(1, ("prefix path %s", vol->prepath));
1077 } else {
1078 printk(KERN_WARNING "CIFS: prefix too long\n");
1079 return 1;
1080 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 } else if (strnicmp(data, "iocharset", 9) == 0) {
1082 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001083 printk(KERN_WARNING "CIFS: invalid iocharset "
1084 "specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 return 1; /* needs_arg; */
1086 }
1087 if (strnlen(value, 65) < 65) {
Steve French50c2f752007-07-13 00:33:32 +00001088 if (strnicmp(value, "default", 7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 vol->iocharset = value;
Steve French50c2f752007-07-13 00:33:32 +00001090 /* if iocharset not set then load_nls_default
1091 is used by caller */
1092 cFYI(1, ("iocharset set to %s", value));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 } else {
Steve French63135e02007-07-17 17:34:02 +00001094 printk(KERN_WARNING "CIFS: iocharset name "
1095 "too long.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 return 1;
1097 }
1098 } else if (strnicmp(data, "uid", 3) == 0) {
Jeff Layton4ae15072009-05-24 18:45:15 -04001099 if (value && *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 vol->linux_uid =
1101 simple_strtoul(value, &value, 0);
Jeff Layton4ae15072009-05-24 18:45:15 -04001102 } else if (strnicmp(data, "forceuid", 8) == 0) {
Steve French4523cc32007-04-30 20:13:06 +00001103 vol->override_uid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 } else if (strnicmp(data, "gid", 3) == 0) {
Jeff Layton4ae15072009-05-24 18:45:15 -04001105 if (value && *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 vol->linux_gid =
1107 simple_strtoul(value, &value, 0);
Jeff Layton4ae15072009-05-24 18:45:15 -04001108 } else if (strnicmp(data, "forcegid", 8) == 0) {
Steve French4523cc32007-04-30 20:13:06 +00001109 vol->override_gid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 } else if (strnicmp(data, "file_mode", 4) == 0) {
1111 if (value && *value) {
1112 vol->file_mode =
1113 simple_strtoul(value, &value, 0);
1114 }
1115 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1116 if (value && *value) {
1117 vol->dir_mode =
1118 simple_strtoul(value, &value, 0);
1119 }
1120 } else if (strnicmp(data, "dirmode", 4) == 0) {
1121 if (value && *value) {
1122 vol->dir_mode =
1123 simple_strtoul(value, &value, 0);
1124 }
1125 } else if (strnicmp(data, "port", 4) == 0) {
1126 if (value && *value) {
1127 vol->port =
1128 simple_strtoul(value, &value, 0);
1129 }
1130 } else if (strnicmp(data, "rsize", 5) == 0) {
1131 if (value && *value) {
1132 vol->rsize =
1133 simple_strtoul(value, &value, 0);
1134 }
1135 } else if (strnicmp(data, "wsize", 5) == 0) {
1136 if (value && *value) {
1137 vol->wsize =
1138 simple_strtoul(value, &value, 0);
1139 }
1140 } else if (strnicmp(data, "sockopt", 5) == 0) {
1141 if (value && *value) {
1142 vol->sockopt =
1143 simple_strtoul(value, &value, 0);
1144 }
1145 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1146 if (!value || !*value || (*value == ' ')) {
Steve French63135e02007-07-17 17:34:02 +00001147 cFYI(1, ("invalid (empty) netbiosname"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 } else {
Steve French50c2f752007-07-13 00:33:32 +00001149 memset(vol->source_rfc1001_name, 0x20, 15);
1150 for (i = 0; i < 15; i++) {
1151 /* BB are there cases in which a comma can be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 valid in this workstation netbios name (and need
1153 special handling)? */
1154
1155 /* We do not uppercase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001156 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 break;
Steve French50c2f752007-07-13 00:33:32 +00001158 else
1159 vol->source_rfc1001_name[i] =
1160 value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 }
1162 /* The string has 16th byte zero still from
1163 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001164 if ((i == 15) && (value[i] != 0))
1165 printk(KERN_WARNING "CIFS: netbiosname"
1166 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001167 }
1168 } else if (strnicmp(data, "servern", 7) == 0) {
1169 /* servernetbiosname specified override *SMBSERVER */
1170 if (!value || !*value || (*value == ' ')) {
Steve French467a8f82007-06-27 22:41:32 +00001171 cFYI(1, ("empty server netbiosname specified"));
Steve Frencha10faeb22005-08-22 21:38:31 -07001172 } else {
1173 /* last byte, type, is 0x20 for servr type */
Steve French50c2f752007-07-13 00:33:32 +00001174 memset(vol->target_rfc1001_name, 0x20, 16);
Steve Frencha10faeb22005-08-22 21:38:31 -07001175
Steve French50c2f752007-07-13 00:33:32 +00001176 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001177 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001178 valid in this workstation netbios name
1179 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001180
Steve French50c2f752007-07-13 00:33:32 +00001181 /* user or mount helper must uppercase
1182 the netbiosname */
1183 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001184 break;
1185 else
Steve French50c2f752007-07-13 00:33:32 +00001186 vol->target_rfc1001_name[i] =
1187 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001188 }
1189 /* The string has 16th byte zero still from
1190 set at top of the function */
Steve French50c2f752007-07-13 00:33:32 +00001191 if ((i == 15) && (value[i] != 0))
1192 printk(KERN_WARNING "CIFS: server net"
1193 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 }
1195 } else if (strnicmp(data, "credentials", 4) == 0) {
1196 /* ignore */
1197 } else if (strnicmp(data, "version", 3) == 0) {
1198 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001199 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 /* ignore */
1201 } else if (strnicmp(data, "rw", 2) == 0) {
Steve French4b18f2a2008-04-29 00:06:05 +00001202 vol->rw = true;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001203 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1204 vol->noblocksnd = 1;
1205 } else if (strnicmp(data, "noautotune", 10) == 0) {
1206 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 } else if ((strnicmp(data, "suid", 4) == 0) ||
1208 (strnicmp(data, "nosuid", 6) == 0) ||
1209 (strnicmp(data, "exec", 4) == 0) ||
1210 (strnicmp(data, "noexec", 6) == 0) ||
1211 (strnicmp(data, "nodev", 5) == 0) ||
1212 (strnicmp(data, "noauto", 6) == 0) ||
1213 (strnicmp(data, "dev", 3) == 0)) {
1214 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001215 uses these opts to set flags, and the flags are read
1216 by the kernel vfs layer before we get here (ie
1217 before read super) so there is no point trying to
1218 parse these options again and set anything and it
1219 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 continue;
1221 } else if (strnicmp(data, "ro", 2) == 0) {
Steve French4b18f2a2008-04-29 00:06:05 +00001222 vol->rw = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 } else if (strnicmp(data, "hard", 4) == 0) {
1224 vol->retry = 1;
1225 } else if (strnicmp(data, "soft", 4) == 0) {
1226 vol->retry = 0;
1227 } else if (strnicmp(data, "perm", 4) == 0) {
1228 vol->noperm = 0;
1229 } else if (strnicmp(data, "noperm", 6) == 0) {
1230 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001231 } else if (strnicmp(data, "mapchars", 8) == 0) {
1232 vol->remap = 1;
1233 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1234 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001235 } else if (strnicmp(data, "sfu", 3) == 0) {
1236 vol->sfu_emul = 1;
1237 } else if (strnicmp(data, "nosfu", 5) == 0) {
1238 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001239 } else if (strnicmp(data, "nodfs", 5) == 0) {
1240 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001241 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1242 vol->posix_paths = 1;
1243 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1244 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001245 } else if (strnicmp(data, "nounix", 6) == 0) {
1246 vol->no_linux_ext = 1;
1247 } else if (strnicmp(data, "nolinux", 7) == 0) {
1248 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001249 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001250 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001251 vol->nocase = 1;
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001252 } else if (strnicmp(data, "brl", 3) == 0) {
1253 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001254 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001255 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001256 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001257 /* turn off mandatory locking in mode
1258 if remote locking is turned off since the
1259 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001260 if (vol->file_mode ==
1261 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001262 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001263 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1264 /* will take the shorter form "forcemand" as well */
1265 /* This mount option will force use of mandatory
1266 (DOS/Windows style) byte range locks, instead of
1267 using posix advisory byte range locks, even if the
1268 Unix extensions are available and posix locks would
1269 be supported otherwise. If Unix extensions are not
1270 negotiated this has no effect since mandatory locks
1271 would be used (mandatory locks is all that those
1272 those servers support) */
1273 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 } else if (strnicmp(data, "setuids", 7) == 0) {
1275 vol->setuids = 1;
1276 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1277 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001278 } else if (strnicmp(data, "dynperm", 7) == 0) {
1279 vol->dynperm = true;
1280 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1281 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 } else if (strnicmp(data, "nohard", 6) == 0) {
1283 vol->retry = 0;
1284 } else if (strnicmp(data, "nosoft", 6) == 0) {
1285 vol->retry = 1;
1286 } else if (strnicmp(data, "nointr", 6) == 0) {
1287 vol->intr = 0;
1288 } else if (strnicmp(data, "intr", 4) == 0) {
1289 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001290 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1291 vol->nostrictsync = 1;
1292 } else if (strnicmp(data, "strictsync", 10) == 0) {
1293 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001294 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001296 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001298 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001299 vol->cifs_acl = 1;
1300 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1301 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001302 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001304 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001306#ifdef CONFIG_CIFS_EXPERIMENTAL
1307 } else if (strnicmp(data, "locallease", 6) == 0) {
1308 vol->local_lease = 1;
1309#endif
Steve French50c2f752007-07-13 00:33:32 +00001310 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001311 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001312 } else if (strnicmp(data, "seal", 4) == 0) {
1313 /* we do not do the following in secFlags because seal
1314 is a per tree connection (mount) not a per socket
1315 or per-smb connection option in the protocol */
1316 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1317 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001318 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001320 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 vol->direct_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001323 printk(KERN_WARNING "CIFS: Mount option noac not "
1324 "supported. Instead set "
1325 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 } else
Steve French50c2f752007-07-13 00:33:32 +00001327 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1328 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001331 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001332 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1333 "target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 return 1;
1335 }
1336 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001337 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001338 if (vol->UNC == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 return 1;
Steve French50c2f752007-07-13 00:33:32 +00001340 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 if (strncmp(vol->UNC, "//", 2) == 0) {
1342 vol->UNC[0] = '\\';
1343 vol->UNC[1] = '\\';
1344 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001345 printk(KERN_WARNING "CIFS: UNC Path does not "
1346 "begin with // or \\\\ \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 return 1;
1348 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001349 value = strpbrk(vol->UNC+2, "/\\");
1350 if (value)
1351 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 } else {
1353 printk(KERN_WARNING "CIFS: UNC name too long\n");
1354 return 1;
1355 }
1356 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001357 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 vol->UNCip = &vol->UNC[2];
1359
1360 return 0;
1361}
1362
Jeff Laytone7ddee92008-11-14 13:44:38 -05001363static struct TCP_Server_Info *
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001364cifs_find_tcp_session(struct sockaddr_storage *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
1366 struct list_head *tmp;
Jeff Laytone7ddee92008-11-14 13:44:38 -05001367 struct TCP_Server_Info *server;
1368 struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1369 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Jeff Laytone7ddee92008-11-14 13:44:38 -05001371 write_lock(&cifs_tcp_ses_lock);
1372 list_for_each(tmp, &cifs_tcp_ses_list) {
1373 server = list_entry(tmp, struct TCP_Server_Info,
1374 tcp_ses_list);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001375 /*
1376 * the demux thread can exit on its own while still in CifsNew
1377 * so don't accept any sockets in that state. Since the
1378 * tcpStatus never changes back to CifsNew it's safe to check
1379 * for this without a lock.
1380 */
1381 if (server->tcpStatus == CifsNew)
Cyrill Gorcunov1b20d672008-05-09 18:17:21 +00001382 continue;
Steve French50c2f752007-07-13 00:33:32 +00001383
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001384 if (addr->ss_family == AF_INET &&
Jeff Laytone7ddee92008-11-14 13:44:38 -05001385 (addr4->sin_addr.s_addr !=
1386 server->addr.sockAddr.sin_addr.s_addr))
1387 continue;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001388 else if (addr->ss_family == AF_INET6 &&
Jeff Layton681bf722009-06-11 10:27:31 -04001389 (!ipv6_addr_equal(&server->addr.sockAddr6.sin6_addr,
1390 &addr6->sin6_addr) ||
1391 server->addr.sockAddr6.sin6_scope_id !=
1392 addr6->sin6_scope_id))
Jeff Laytone7ddee92008-11-14 13:44:38 -05001393 continue;
Steve French50c2f752007-07-13 00:33:32 +00001394
Jeff Laytone7ddee92008-11-14 13:44:38 -05001395 ++server->srv_count;
1396 write_unlock(&cifs_tcp_ses_lock);
Steve Frenchd82c2df2008-11-15 00:07:26 +00001397 cFYI(1, ("Existing tcp session with server found"));
Jeff Laytone7ddee92008-11-14 13:44:38 -05001398 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 }
Jeff Laytone7ddee92008-11-14 13:44:38 -05001400 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 return NULL;
1402}
1403
Jeff Layton14fbf502008-11-14 13:53:46 -05001404static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001405cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001407 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
Jeff Laytone7ddee92008-11-14 13:44:38 -05001409 write_lock(&cifs_tcp_ses_lock);
1410 if (--server->srv_count > 0) {
1411 write_unlock(&cifs_tcp_ses_lock);
1412 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001414
Jeff Laytone7ddee92008-11-14 13:44:38 -05001415 list_del_init(&server->tcp_ses_list);
1416 write_unlock(&cifs_tcp_ses_lock);
1417
1418 spin_lock(&GlobalMid_Lock);
1419 server->tcpStatus = CifsExiting;
1420 spin_unlock(&GlobalMid_Lock);
1421
1422 task = xchg(&server->tsk, NULL);
1423 if (task)
1424 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425}
1426
Jeff Layton63c038c2008-12-01 18:41:46 -05001427static struct TCP_Server_Info *
1428cifs_get_tcp_session(struct smb_vol *volume_info)
1429{
1430 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001431 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001432 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1433 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1434 int rc;
1435
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001436 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001437
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001438 cFYI(1, ("UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip));
1439
Jeff Layton63c038c2008-12-01 18:41:46 -05001440 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001441 rc = cifs_convert_address(volume_info->UNCip, &addr);
1442 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001443 /* we failed translating address */
1444 rc = -EINVAL;
1445 goto out_err;
1446 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001447 } else if (volume_info->UNCip) {
1448 /* BB using ip addr as tcp_ses name to connect to the
1449 DFS root below */
1450 cERROR(1, ("Connecting to DFS root not implemented yet"));
1451 rc = -EINVAL;
1452 goto out_err;
1453 } else /* which tcp_sess DFS root would we conect to */ {
1454 cERROR(1,
1455 ("CIFS mount error: No UNC path (e.g. -o "
1456 "unc=//192.168.1.100/public) specified"));
1457 rc = -EINVAL;
1458 goto out_err;
1459 }
1460
1461 /* see if we already have a matching tcp_ses */
1462 tcp_ses = cifs_find_tcp_session(&addr);
1463 if (tcp_ses)
1464 return tcp_ses;
1465
1466 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1467 if (!tcp_ses) {
1468 rc = -ENOMEM;
1469 goto out_err;
1470 }
1471
1472 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1473 if (IS_ERR(tcp_ses->hostname)) {
1474 rc = PTR_ERR(tcp_ses->hostname);
1475 goto out_err;
1476 }
1477
1478 tcp_ses->noblocksnd = volume_info->noblocksnd;
1479 tcp_ses->noautotune = volume_info->noautotune;
1480 atomic_set(&tcp_ses->inFlight, 0);
1481 init_waitqueue_head(&tcp_ses->response_q);
1482 init_waitqueue_head(&tcp_ses->request_q);
1483 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1484 mutex_init(&tcp_ses->srv_mutex);
1485 memcpy(tcp_ses->workstation_RFC1001_name,
1486 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1487 memcpy(tcp_ses->server_RFC1001_name,
1488 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1489 tcp_ses->sequence_number = 0;
1490 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1491 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1492
1493 /*
1494 * at this point we are the only ones with the pointer
1495 * to the struct since the kernel thread not created yet
1496 * no need to spinlock this init of tcpStatus or srv_count
1497 */
1498 tcp_ses->tcpStatus = CifsNew;
1499 ++tcp_ses->srv_count;
1500
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001501 if (addr.ss_family == AF_INET6) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001502 cFYI(1, ("attempting ipv6 connect"));
1503 /* BB should we allow ipv6 on port 139? */
1504 /* other OS never observed in Wild doing 139 with v6 */
1505 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1506 sizeof(struct sockaddr_in6));
1507 sin_server6->sin6_port = htons(volume_info->port);
Jeff Laytond5c56052008-12-01 18:42:33 -05001508 rc = ipv6_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001509 } else {
1510 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1511 sizeof(struct sockaddr_in));
1512 sin_server->sin_port = htons(volume_info->port);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001513 rc = ipv4_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001514 }
1515 if (rc < 0) {
1516 cERROR(1, ("Error connecting to socket. Aborting operation"));
1517 goto out_err;
1518 }
1519
1520 /*
1521 * since we're in a cifs function already, we know that
1522 * this will succeed. No need for try_module_get().
1523 */
1524 __module_get(THIS_MODULE);
1525 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1526 tcp_ses, "cifsd");
1527 if (IS_ERR(tcp_ses->tsk)) {
1528 rc = PTR_ERR(tcp_ses->tsk);
1529 cERROR(1, ("error %d create cifsd thread", rc));
1530 module_put(THIS_MODULE);
1531 goto out_err;
1532 }
1533
1534 /* thread spawned, put it on the list */
1535 write_lock(&cifs_tcp_ses_lock);
1536 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1537 write_unlock(&cifs_tcp_ses_lock);
1538
1539 return tcp_ses;
1540
1541out_err:
1542 if (tcp_ses) {
1543 kfree(tcp_ses->hostname);
1544 if (tcp_ses->ssocket)
1545 sock_release(tcp_ses->ssocket);
1546 kfree(tcp_ses);
1547 }
1548 return ERR_PTR(rc);
1549}
1550
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551static struct cifsSesInfo *
Jeff Layton14fbf502008-11-14 13:53:46 -05001552cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553{
1554 struct list_head *tmp;
1555 struct cifsSesInfo *ses;
1556
Jeff Layton14fbf502008-11-14 13:53:46 -05001557 write_lock(&cifs_tcp_ses_lock);
1558 list_for_each(tmp, &server->smb_ses_list) {
1559 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1560 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 continue;
1562
Jeff Layton14fbf502008-11-14 13:53:46 -05001563 ++ses->ses_count;
1564 write_unlock(&cifs_tcp_ses_lock);
1565 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 }
Jeff Layton14fbf502008-11-14 13:53:46 -05001567 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 return NULL;
1569}
1570
Jeff Layton14fbf502008-11-14 13:53:46 -05001571static void
1572cifs_put_smb_ses(struct cifsSesInfo *ses)
1573{
1574 int xid;
1575 struct TCP_Server_Info *server = ses->server;
1576
1577 write_lock(&cifs_tcp_ses_lock);
1578 if (--ses->ses_count > 0) {
1579 write_unlock(&cifs_tcp_ses_lock);
1580 return;
1581 }
1582
1583 list_del_init(&ses->smb_ses_list);
1584 write_unlock(&cifs_tcp_ses_lock);
1585
1586 if (ses->status == CifsGood) {
1587 xid = GetXid();
1588 CIFSSMBLogoff(xid, ses);
1589 _FreeXid(xid);
1590 }
1591 sesInfoFree(ses);
1592 cifs_put_tcp_session(server);
1593}
1594
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05001596cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597{
1598 struct list_head *tmp;
1599 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
Jeff Laytonf1987b42008-11-15 11:12:47 -05001601 write_lock(&cifs_tcp_ses_lock);
1602 list_for_each(tmp, &ses->tcon_list) {
1603 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1604 if (tcon->tidStatus == CifsExiting)
1605 continue;
1606 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 continue;
1608
Jeff Laytonf1987b42008-11-15 11:12:47 -05001609 ++tcon->tc_count;
1610 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 return tcon;
1612 }
Jeff Laytonf1987b42008-11-15 11:12:47 -05001613 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 return NULL;
1615}
1616
Jeff Laytonf1987b42008-11-15 11:12:47 -05001617static void
1618cifs_put_tcon(struct cifsTconInfo *tcon)
1619{
1620 int xid;
1621 struct cifsSesInfo *ses = tcon->ses;
1622
1623 write_lock(&cifs_tcp_ses_lock);
1624 if (--tcon->tc_count > 0) {
1625 write_unlock(&cifs_tcp_ses_lock);
1626 return;
1627 }
1628
1629 list_del_init(&tcon->tcon_list);
1630 write_unlock(&cifs_tcp_ses_lock);
1631
1632 xid = GetXid();
1633 CIFSSMBTDis(xid, tcon);
1634 _FreeXid(xid);
1635
1636 DeleteTconOplockQEntries(tcon);
1637 tconInfoFree(tcon);
1638 cifs_put_smb_ses(ses);
1639}
1640
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641int
Steve French50c2f752007-07-13 00:33:32 +00001642get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1643 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00001644 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645{
1646 char *temp_unc;
1647 int rc = 0;
1648
1649 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00001650 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
1652 if (pSesInfo->ipc_tid == 0) {
1653 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00001654 strnlen(pSesInfo->serverName,
1655 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 + 1 + 4 /* slash IPC$ */ + 2,
1657 GFP_KERNEL);
1658 if (temp_unc == NULL)
1659 return -ENOMEM;
1660 temp_unc[0] = '\\';
1661 temp_unc[1] = '\\';
1662 strcpy(temp_unc + 2, pSesInfo->serverName);
1663 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1664 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1665 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +00001666 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 kfree(temp_unc);
1668 }
1669 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00001670 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07001671 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00001672 /* BB map targetUNCs to dfs_info3 structures, here or
1673 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
1675 return rc;
1676}
1677
Jeff Layton09e50d52008-07-23 10:11:19 -04001678#ifdef CONFIG_DEBUG_LOCK_ALLOC
1679static struct lock_class_key cifs_key[2];
1680static struct lock_class_key cifs_slock_key[2];
1681
1682static inline void
1683cifs_reclassify_socket4(struct socket *sock)
1684{
1685 struct sock *sk = sock->sk;
1686 BUG_ON(sock_owned_by_user(sk));
1687 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1688 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1689}
1690
1691static inline void
1692cifs_reclassify_socket6(struct socket *sock)
1693{
1694 struct sock *sk = sock->sk;
1695 BUG_ON(sock_owned_by_user(sk));
1696 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1697 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1698}
1699#else
1700static inline void
1701cifs_reclassify_socket4(struct socket *sock)
1702{
1703}
1704
1705static inline void
1706cifs_reclassify_socket6(struct socket *sock)
1707{
1708}
1709#endif
1710
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00001712static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713{
Steve French50c2f752007-07-13 00:33:32 +00001714 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715
Steve French50c2f752007-07-13 00:33:32 +00001716 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 /* mask a nibble at a time and encode */
1718 target[j] = 'A' + (0x0F & (source[i] >> 4));
1719 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00001720 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 }
1722
1723}
1724
1725
1726static int
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001727ipv4_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728{
1729 int rc = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001730 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 __be16 orig_port = 0;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001732 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001734 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001735 rc = sock_create_kern(PF_INET, SOCK_STREAM,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001736 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001738 cERROR(1, ("Error %d creating socket", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001741
1742 /* BB other socket options to set KEEPALIVE, NODELAY? */
1743 cFYI(1, ("Socket created"));
1744 server->ssocket = socket;
1745 socket->sk->sk_allocation = GFP_NOFS;
1746 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 }
1748
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001749 /* user overrode default port */
1750 if (server->addr.sockAddr.sin_port) {
1751 rc = socket->ops->connect(socket, (struct sockaddr *)
1752 &server->addr.sockAddr,
1753 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001755 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001758 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001759 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 later if fall back ports fail this time */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001761 orig_port = server->addr.sockAddr.sin_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
1763 /* do not retry on the same port we just failed on */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001764 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
1765 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
1766 rc = socket->ops->connect(socket,
1767 (struct sockaddr *)
1768 &server->addr.sockAddr,
1769 sizeof(struct sockaddr_in), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001771 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 }
1773 }
1774 if (!connected) {
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001775 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
1776 rc = socket->ops->connect(socket, (struct sockaddr *)
1777 &server->addr.sockAddr,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001778 sizeof(struct sockaddr_in), 0);
Steve French50c2f752007-07-13 00:33:32 +00001779 if (rc >= 0)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001780 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 }
1782
1783 /* give up here - unless we want to retry on different
1784 protocol families some day */
1785 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001786 if (orig_port)
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001787 server->addr.sockAddr.sin_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001788 cFYI(1, ("Error %d connecting to server via ipv4", rc));
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001789 sock_release(socket);
1790 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 return rc;
1792 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001793
1794
1795 /*
1796 * Eventually check for other socket options to change from
1797 * the default. sock_setsockopt not used because it expects
1798 * user space buffer
1799 */
1800 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001801 socket->sk->sk_sndtimeo = 5 * HZ;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001802
Steve Frenchb387eae2005-10-10 14:21:15 -07001803 /* make the bufsizes depend on wsize/rsize and max requests */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001804 if (server->noautotune) {
1805 if (socket->sk->sk_sndbuf < (200 * 1024))
1806 socket->sk->sk_sndbuf = 200 * 1024;
1807 if (socket->sk->sk_rcvbuf < (140 * 1024))
1808 socket->sk->sk_rcvbuf = 140 * 1024;
Steve Frenchedf1ae42008-10-29 00:47:57 +00001809 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001811 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1812 socket->sk->sk_sndbuf,
1813 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo));
1814
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 /* send RFC1001 sessinit */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001816 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 /* some servers require RFC1001 sessinit before sending
Steve French50c2f752007-07-13 00:33:32 +00001818 negprot - BB check reconnection in case where second
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 sessinit is sent but no second negprot */
Steve French50c2f752007-07-13 00:33:32 +00001820 struct rfc1002_session_packet *ses_init_buf;
1821 struct smb_hdr *smb_buf;
1822 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1823 GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001824 if (ses_init_buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 ses_init_buf->trailer.session_req.called_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001826 if (server->server_RFC1001_name &&
1827 server->server_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001828 rfc1002mangle(ses_init_buf->trailer.
1829 session_req.called_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001830 server->server_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001831 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001832 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001833 rfc1002mangle(ses_init_buf->trailer.
1834 session_req.called_name,
1835 DEFAULT_CIFS_CALLED_NAME,
1836 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001837
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 ses_init_buf->trailer.session_req.calling_len = 32;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001839
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 /* calling name ends in null (byte 16) from old smb
1841 convention. */
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001842 if (server->workstation_RFC1001_name &&
1843 server->workstation_RFC1001_name[0] != 0)
Jeff Layton8ecaf672008-12-01 15:23:50 -05001844 rfc1002mangle(ses_init_buf->trailer.
1845 session_req.calling_name,
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001846 server->workstation_RFC1001_name,
Jeff Layton8ecaf672008-12-01 15:23:50 -05001847 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001848 else
Jeff Layton8ecaf672008-12-01 15:23:50 -05001849 rfc1002mangle(ses_init_buf->trailer.
1850 session_req.calling_name,
1851 "LINUX_CIFS_CLNT",
1852 RFC1001_NAME_LEN_WITH_NULL);
Jeff Laytonbcf4b102008-12-01 18:42:15 -05001853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 ses_init_buf->trailer.session_req.scope1 = 0;
1855 ses_init_buf->trailer.session_req.scope2 = 0;
1856 smb_buf = (struct smb_hdr *)ses_init_buf;
1857 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1858 smb_buf->smb_buf_length = 0x81000044;
Jeff Layton0496e022008-12-30 12:39:16 -05001859 rc = smb_send(server, smb_buf, 0x44);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 kfree(ses_init_buf);
Steve French50c2f752007-07-13 00:33:32 +00001861 msleep(1); /* RFC1001 layer in at least one server
Steve French083d3a22006-03-03 09:53:36 +00001862 requires very short break before negprot
1863 presumably because not expecting negprot
1864 to follow so fast. This is a simple
Steve French50c2f752007-07-13 00:33:32 +00001865 solution that works without
Steve French083d3a22006-03-03 09:53:36 +00001866 complicating the code and causes no
1867 significant slowing down on mount
1868 for everyone else */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 }
Steve French50c2f752007-07-13 00:33:32 +00001870 /* else the negprot may still work without this
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 even though malloc failed */
Steve French50c2f752007-07-13 00:33:32 +00001872
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 }
Steve French50c2f752007-07-13 00:33:32 +00001874
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 return rc;
1876}
1877
1878static int
Jeff Laytond5c56052008-12-01 18:42:33 -05001879ipv6_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880{
1881 int rc = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001882 bool connected = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 __be16 orig_port = 0;
Jeff Laytond5c56052008-12-01 18:42:33 -05001884 struct socket *socket = server->ssocket;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885
Jeff Laytond5c56052008-12-01 18:42:33 -05001886 if (socket == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001887 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
Jeff Laytond5c56052008-12-01 18:42:33 -05001888 IPPROTO_TCP, &socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 if (rc < 0) {
Steve French50c2f752007-07-13 00:33:32 +00001890 cERROR(1, ("Error %d creating ipv6 socket", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001891 socket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 }
Jeff Laytond5c56052008-12-01 18:42:33 -05001894
1895 /* BB other socket options to set KEEPALIVE, NODELAY? */
1896 cFYI(1, ("ipv6 Socket created"));
1897 server->ssocket = socket;
1898 socket->sk->sk_allocation = GFP_NOFS;
1899 cifs_reclassify_socket6(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 }
1901
Jeff Laytond5c56052008-12-01 18:42:33 -05001902 /* user overrode default port */
1903 if (server->addr.sockAddr6.sin6_port) {
1904 rc = socket->ops->connect(socket,
1905 (struct sockaddr *) &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001906 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001908 connected = true;
Steve French50c2f752007-07-13 00:33:32 +00001909 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001911 if (!connected) {
Steve French50c2f752007-07-13 00:33:32 +00001912 /* save original port so we can retry user specified port
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 later if fall back ports fail this time */
1914
Jeff Laytond5c56052008-12-01 18:42:33 -05001915 orig_port = server->addr.sockAddr6.sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 /* do not retry on the same port we just failed on */
Jeff Laytond5c56052008-12-01 18:42:33 -05001917 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
1918 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
1919 rc = socket->ops->connect(socket, (struct sockaddr *)
1920 &server->addr.sockAddr6,
Cyrill Gorcunov6345a3a2007-10-16 17:57:55 +00001921 sizeof(struct sockaddr_in6), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001923 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 }
1925 }
1926 if (!connected) {
Jeff Laytond5c56052008-12-01 18:42:33 -05001927 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
1928 rc = socket->ops->connect(socket, (struct sockaddr *)
1929 &server->addr.sockAddr6,
1930 sizeof(struct sockaddr_in6), 0);
Steve French50c2f752007-07-13 00:33:32 +00001931 if (rc >= 0)
Jeff Laytond5c56052008-12-01 18:42:33 -05001932 connected = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 }
1934
1935 /* give up here - unless we want to retry on different
1936 protocol families some day */
1937 if (!connected) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001938 if (orig_port)
Jeff Laytond5c56052008-12-01 18:42:33 -05001939 server->addr.sockAddr6.sin6_port = orig_port;
Steve French50c2f752007-07-13 00:33:32 +00001940 cFYI(1, ("Error %d connecting to server via ipv6", rc));
Jeff Laytond5c56052008-12-01 18:42:33 -05001941 sock_release(socket);
1942 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 return rc;
1944 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00001945
Jeff Laytond5c56052008-12-01 18:42:33 -05001946 /*
1947 * Eventually check for other socket options to change from
1948 * the default. sock_setsockopt not used because it expects
1949 * user space buffer
1950 */
1951 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00001952 socket->sk->sk_sndtimeo = 5 * HZ;
Jeff Laytond5c56052008-12-01 18:42:33 -05001953 server->ssocket = socket;
Steve French50c2f752007-07-13 00:33:32 +00001954
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 return rc;
1956}
1957
Steve French50c2f752007-07-13 00:33:32 +00001958void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1959 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00001960{
1961 /* if we are reconnecting then should we check to see if
1962 * any requested capabilities changed locally e.g. via
1963 * remount but we can not do much about it here
1964 * if they have (even if we could detect it by the following)
1965 * Perhaps we could add a backpointer to array of sb from tcon
1966 * or if we change to make all sb to same share the same
1967 * sb as NFS - then we only have one backpointer to sb.
1968 * What if we wanted to mount the server share twice once with
1969 * and once without posixacls or posix paths? */
1970 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001971
Steve Frenchc18c8422007-07-18 23:21:09 +00001972 if (vol_info && vol_info->no_linux_ext) {
1973 tcon->fsUnixInfo.Capability = 0;
1974 tcon->unix_ext = 0; /* Unix Extensions disabled */
1975 cFYI(1, ("Linux protocol extensions disabled"));
1976 return;
1977 } else if (vol_info)
1978 tcon->unix_ext = 1; /* Unix Extensions supported */
1979
1980 if (tcon->unix_ext == 0) {
1981 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1982 return;
1983 }
Steve French50c2f752007-07-13 00:33:32 +00001984
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001985 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00001986 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00001987
Steve French8af18972007-02-14 04:42:51 +00001988 /* check for reconnect case in which we do not
1989 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001990 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001991 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00001992 originally at mount time */
1993 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1994 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00001995 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1996 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1997 cERROR(1, ("POSIXPATH support change"));
Steve French8af18972007-02-14 04:42:51 +00001998 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00001999 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2000 cERROR(1, ("possible reconnect error"));
2001 cERROR(1,
2002 ("server disabled POSIX path support"));
2003 }
Steve French8af18972007-02-14 04:42:51 +00002004 }
Steve French50c2f752007-07-13 00:33:32 +00002005
Steve French8af18972007-02-14 04:42:51 +00002006 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002007 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002008 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002009 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002010 cFYI(1, ("negotiated posix acl support"));
2011 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002012 sb->s_flags |= MS_POSIXACL;
2013 }
2014
Steve French75865f8c2007-06-24 18:30:48 +00002015 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002016 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002017 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002018 cFYI(1, ("negotiate posix pathnames"));
Steve French75865f8c2007-06-24 18:30:48 +00002019 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002020 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002021 CIFS_MOUNT_POSIX_PATHS;
2022 }
Steve French50c2f752007-07-13 00:33:32 +00002023
Steve French984acfe2007-04-26 16:42:50 +00002024 /* We might be setting the path sep back to a different
2025 form if we are reconnecting and the server switched its
Steve French50c2f752007-07-13 00:33:32 +00002026 posix path capability for this share */
Steve French75865f8c2007-06-24 18:30:48 +00002027 if (sb && (CIFS_SB(sb)->prepathlen > 0))
Steve French984acfe2007-04-26 16:42:50 +00002028 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
Steve French75865f8c2007-06-24 18:30:48 +00002029
2030 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2031 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2032 CIFS_SB(sb)->rsize = 127 * 1024;
Steve French90c81e02008-02-12 20:32:36 +00002033 cFYI(DBG2,
2034 ("larger reads not supported by srv"));
Steve French75865f8c2007-06-24 18:30:48 +00002035 }
2036 }
Steve French50c2f752007-07-13 00:33:32 +00002037
2038
2039 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
Steve French8af18972007-02-14 04:42:51 +00002040#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002041 if (cap & CIFS_UNIX_FCNTL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002042 cFYI(1, ("FCNTL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002043 if (cap & CIFS_UNIX_EXTATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002044 cFYI(1, ("EXTATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002045 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002046 cFYI(1, ("POSIX path cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002047 if (cap & CIFS_UNIX_XATTR_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002048 cFYI(1, ("XATTR cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002049 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002050 cFYI(1, ("POSIX ACL cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002051 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002052 cFYI(1, ("very large read cap"));
Steve French75865f8c2007-06-24 18:30:48 +00002053 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002054 cFYI(1, ("very large write cap"));
Steve French8af18972007-02-14 04:42:51 +00002055#endif /* CIFS_DEBUG2 */
2056 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002057 if (vol_info == NULL) {
Steve French5a44b312007-09-20 15:16:24 +00002058 cFYI(1, ("resetting capabilities failed"));
Steve French442aa312007-09-24 20:25:46 +00002059 } else
Steve French5a44b312007-09-20 15:16:24 +00002060 cERROR(1, ("Negotiating Unix capabilities "
2061 "with the server failed. Consider "
2062 "mounting with the Unix Extensions\n"
2063 "disabled, if problems are found, "
2064 "by specifying the nounix mount "
Steve French2224f4e2007-09-20 15:37:29 +00002065 "option."));
Steve French5a44b312007-09-20 15:16:24 +00002066
Steve French8af18972007-02-14 04:42:51 +00002067 }
2068 }
2069}
2070
Steve French03a143c2008-02-14 06:38:30 +00002071static void
2072convert_delimiter(char *path, char delim)
2073{
2074 int i;
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002075 char old_delim;
Steve French03a143c2008-02-14 06:38:30 +00002076
2077 if (path == NULL)
2078 return;
2079
Steve French582d21e2008-05-13 04:54:12 +00002080 if (delim == '/')
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002081 old_delim = '\\';
2082 else
2083 old_delim = '/';
2084
Steve French03a143c2008-02-14 06:38:30 +00002085 for (i = 0; path[i] != '\0'; i++) {
Steve Frenchc2d68ea2008-02-15 19:20:18 +00002086 if (path[i] == old_delim)
Steve French03a143c2008-02-14 06:38:30 +00002087 path[i] = delim;
2088 }
2089}
2090
Steve French3b795212008-11-13 19:45:32 +00002091static void setup_cifs_sb(struct smb_vol *pvolume_info,
2092 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002093{
Steve French3b795212008-11-13 19:45:32 +00002094 if (pvolume_info->rsize > CIFSMaxBufSize) {
2095 cERROR(1, ("rsize %d too large, using MaxBufSize",
2096 pvolume_info->rsize));
2097 cifs_sb->rsize = CIFSMaxBufSize;
2098 } else if ((pvolume_info->rsize) &&
2099 (pvolume_info->rsize <= CIFSMaxBufSize))
2100 cifs_sb->rsize = pvolume_info->rsize;
2101 else /* default */
2102 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002103
Steve French3b795212008-11-13 19:45:32 +00002104 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2105 cERROR(1, ("wsize %d too large, using 4096 instead",
2106 pvolume_info->wsize));
2107 cifs_sb->wsize = 4096;
2108 } else if (pvolume_info->wsize)
2109 cifs_sb->wsize = pvolume_info->wsize;
2110 else
2111 cifs_sb->wsize = min_t(const int,
2112 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2113 127*1024);
2114 /* old default of CIFSMaxBufSize was too small now
2115 that SMB Write2 can send multiple pages in kvec.
2116 RFC1001 does not describe what happens when frame
2117 bigger than 128K is sent so use that as max in
2118 conjunction with 52K kvec constraint on arch with 4K
2119 page size */
2120
2121 if (cifs_sb->rsize < 2048) {
2122 cifs_sb->rsize = 2048;
2123 /* Windows ME may prefer this */
2124 cFYI(1, ("readsize set to minimum: 2048"));
2125 }
2126 /* calculate prepath */
2127 cifs_sb->prepath = pvolume_info->prepath;
2128 if (cifs_sb->prepath) {
2129 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2130 /* we can not convert the / to \ in the path
2131 separators in the prefixpath yet because we do not
2132 know (until reset_cifs_unix_caps is called later)
2133 whether POSIX PATH CAP is available. We normalize
2134 the / to \ after reset_cifs_unix_caps is called */
2135 pvolume_info->prepath = NULL;
2136 } else
2137 cifs_sb->prepathlen = 0;
2138 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2139 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2140 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2141 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2142 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2143 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2144
2145 if (pvolume_info->noperm)
2146 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2147 if (pvolume_info->setuids)
2148 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2149 if (pvolume_info->server_ino)
2150 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2151 if (pvolume_info->remap)
2152 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2153 if (pvolume_info->no_xattr)
2154 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2155 if (pvolume_info->sfu_emul)
2156 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2157 if (pvolume_info->nobrl)
2158 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002159 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002160 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002161 if (pvolume_info->mand_lock)
2162 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002163 if (pvolume_info->cifs_acl)
2164 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2165 if (pvolume_info->override_uid)
2166 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2167 if (pvolume_info->override_gid)
2168 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2169 if (pvolume_info->dynperm)
2170 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2171 if (pvolume_info->direct_io) {
2172 cFYI(1, ("mounting share using direct i/o"));
2173 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2174 }
2175
2176 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2177 cERROR(1, ("mount option dynperm ignored if cifsacl "
2178 "mount option supported"));
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002179}
2180
Igor Mammedove4cce942009-02-10 14:10:26 +03002181static int
2182is_path_accessible(int xid, struct cifsTconInfo *tcon,
2183 struct cifs_sb_info *cifs_sb, const char *full_path)
2184{
2185 int rc;
2186 __u64 inode_num;
2187 FILE_ALL_INFO *pfile_info;
2188
2189 rc = CIFSGetSrvInodeNumber(xid, tcon, full_path, &inode_num,
2190 cifs_sb->local_nls,
2191 cifs_sb->mnt_cifs_flags &
2192 CIFS_MOUNT_MAP_SPECIAL_CHR);
2193 if (rc != -EOPNOTSUPP)
2194 return rc;
2195
2196 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2197 if (pfile_info == NULL)
2198 return -ENOMEM;
2199
2200 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2201 0 /* not legacy */, cifs_sb->local_nls,
2202 cifs_sb->mnt_cifs_flags &
2203 CIFS_MOUNT_MAP_SPECIAL_CHR);
2204 kfree(pfile_info);
2205 return rc;
2206}
2207
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002208static void
2209cleanup_volume_info(struct smb_vol **pvolume_info)
2210{
2211 struct smb_vol *volume_info;
2212
2213 if (!pvolume_info && !*pvolume_info)
2214 return;
2215
2216 volume_info = *pvolume_info;
2217 kzfree(volume_info->password);
2218 kfree(volume_info->UNC);
2219 kfree(volume_info->prepath);
2220 kfree(volume_info);
2221 *pvolume_info = NULL;
2222 return;
2223}
2224
Steve French2d6d5892009-04-09 00:36:44 +00002225#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002226/* build_path_to_root returns full path to root when
2227 * we do not have an exiting connection (tcon) */
2228static char *
2229build_unc_path_to_root(const struct smb_vol *volume_info,
2230 const struct cifs_sb_info *cifs_sb)
2231{
2232 char *full_path;
2233
2234 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2235 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2236 if (full_path == NULL)
2237 return ERR_PTR(-ENOMEM);
2238
2239 strncpy(full_path, volume_info->UNC, unc_len);
2240 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2241 int i;
2242 for (i = 0; i < unc_len; i++) {
2243 if (full_path[i] == '\\')
2244 full_path[i] = '/';
2245 }
2246 }
2247
2248 if (cifs_sb->prepathlen)
2249 strncpy(full_path + unc_len, cifs_sb->prepath,
2250 cifs_sb->prepathlen);
2251
2252 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2253 return full_path;
2254}
Steve French2d6d5892009-04-09 00:36:44 +00002255#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002256
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257int
2258cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002259 char *mount_data_global, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260{
2261 int rc = 0;
2262 int xid;
Jeff Layton7586b762008-12-01 18:41:49 -05002263 struct smb_vol *volume_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 struct cifsSesInfo *pSesInfo = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 struct cifsTconInfo *tcon = NULL;
2266 struct TCP_Server_Info *srvTcp = NULL;
Igor Mammedove4cce942009-02-10 14:10:26 +03002267 char *full_path;
Steve French2d6d5892009-04-09 00:36:44 +00002268 char *mount_data = mount_data_global;
2269#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002270 struct dfs_info3_param *referrals = NULL;
2271 unsigned int num_referrals = 0;
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002272 int referral_walks_count = 0;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002273try_mount_again:
Steve French2d6d5892009-04-09 00:36:44 +00002274#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002275 full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276
2277 xid = GetXid();
2278
Jeff Layton7586b762008-12-01 18:41:49 -05002279 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2280 if (!volume_info) {
2281 rc = -ENOMEM;
2282 goto out;
2283 }
Steve French50c2f752007-07-13 00:33:32 +00002284
Jeff Layton7586b762008-12-01 18:41:49 -05002285 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002286 rc = -EINVAL;
2287 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 }
2289
Jeff Layton7586b762008-12-01 18:41:49 -05002290 if (volume_info->nullauth) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002291 cFYI(1, ("null user"));
Jeff Layton7586b762008-12-01 18:41:49 -05002292 volume_info->username = "";
2293 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 /* BB fixme parse for domain name here */
Jeff Layton7586b762008-12-01 18:41:49 -05002295 cFYI(1, ("Username: %s", volume_info->username));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002297 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002298 /* In userspace mount helper we can get user name from alternate
2299 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002300 rc = -EINVAL;
2301 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 }
2303
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304
2305 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002306 if (volume_info->iocharset == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 cifs_sb->local_nls = load_nls_default();
2308 /* load_nls_default can not return null */
2309 } else {
Jeff Layton7586b762008-12-01 18:41:49 -05002310 cifs_sb->local_nls = load_nls(volume_info->iocharset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002311 if (cifs_sb->local_nls == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002312 cERROR(1, ("CIFS mount error: iocharset %s not found",
Jeff Layton7586b762008-12-01 18:41:49 -05002313 volume_info->iocharset));
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002314 rc = -ELIBACC;
2315 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 }
2317 }
2318
Jeff Layton63c038c2008-12-01 18:41:46 -05002319 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05002320 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002321 if (IS_ERR(srvTcp)) {
2322 rc = PTR_ERR(srvTcp);
2323 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 }
2325
Jeff Layton7586b762008-12-01 18:41:49 -05002326 pSesInfo = cifs_find_smb_ses(srvTcp, volume_info->username);
Jeff Layton14fbf502008-11-14 13:53:46 -05002327 if (pSesInfo) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002328 cFYI(1, ("Existing smb sess found (status=%d)",
2329 pSesInfo->status));
Jeff Layton14fbf502008-11-14 13:53:46 -05002330 /*
2331 * The existing SMB session already has a reference to srvTcp,
2332 * so we can put back the extra one we got before
2333 */
2334 cifs_put_tcp_session(srvTcp);
2335
Steve French88e7d702008-01-03 17:37:09 +00002336 down(&pSesInfo->sesSem);
Steve French3b795212008-11-13 19:45:32 +00002337 if (pSesInfo->need_reconnect) {
Jeff Layton1d9a8852007-12-31 01:37:11 +00002338 cFYI(1, ("Session needs reconnect"));
Jeff Layton1d9a8852007-12-31 01:37:11 +00002339 rc = cifs_setup_session(xid, pSesInfo,
2340 cifs_sb->local_nls);
Jeff Layton1d9a8852007-12-31 01:37:11 +00002341 }
Steve French88e7d702008-01-03 17:37:09 +00002342 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 } else if (!rc) {
Steve Frenchbf820672005-12-01 22:32:42 -08002344 cFYI(1, ("Existing smb sess not found"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 pSesInfo = sesInfoAlloc();
Jeff Layton14fbf502008-11-14 13:53:46 -05002346 if (pSesInfo == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 rc = -ENOMEM;
Jeff Layton14fbf502008-11-14 13:53:46 -05002348 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 }
2350
Jeff Layton14fbf502008-11-14 13:53:46 -05002351 /* new SMB session uses our srvTcp ref */
2352 pSesInfo->server = srvTcp;
Jeff Layton63c038c2008-12-01 18:41:46 -05002353 if (srvTcp->addr.sockAddr6.sin6_family == AF_INET6)
Linus Torvalds0191b622008-12-28 12:49:40 -08002354 sprintf(pSesInfo->serverName, "%pI6",
2355 &srvTcp->addr.sockAddr6.sin6_addr);
Jeff Layton8ecaf672008-12-01 15:23:50 -05002356 else
Linus Torvalds0191b622008-12-28 12:49:40 -08002357 sprintf(pSesInfo->serverName, "%pI4",
2358 &srvTcp->addr.sockAddr.sin_addr.s_addr);
Jeff Layton14fbf502008-11-14 13:53:46 -05002359
2360 write_lock(&cifs_tcp_ses_lock);
2361 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2362 write_unlock(&cifs_tcp_ses_lock);
2363
Jeff Layton7586b762008-12-01 18:41:49 -05002364 /* volume_info->password freed at unmount */
2365 if (volume_info->password) {
Jeff Layton00e485b2008-12-05 20:41:21 -05002366 pSesInfo->password = kstrdup(volume_info->password,
2367 GFP_KERNEL);
2368 if (!pSesInfo->password) {
2369 rc = -ENOMEM;
2370 goto mount_fail_check;
2371 }
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002372 }
Jeff Layton7586b762008-12-01 18:41:49 -05002373 if (volume_info->username)
2374 strncpy(pSesInfo->userName, volume_info->username,
Jeff Layton14fbf502008-11-14 13:53:46 -05002375 MAX_USERNAME_SIZE);
Jeff Layton7586b762008-12-01 18:41:49 -05002376 if (volume_info->domainname) {
2377 int len = strlen(volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002378 pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2379 if (pSesInfo->domainName)
2380 strcpy(pSesInfo->domainName,
Jeff Layton7586b762008-12-01 18:41:49 -05002381 volume_info->domainname);
Jeff Layton14fbf502008-11-14 13:53:46 -05002382 }
Jeff Layton7586b762008-12-01 18:41:49 -05002383 pSesInfo->linux_uid = volume_info->linux_uid;
2384 pSesInfo->overrideSecFlg = volume_info->secFlg;
Jeff Layton14fbf502008-11-14 13:53:46 -05002385 down(&pSesInfo->sesSem);
2386
2387 /* BB FIXME need to pass vol->secFlgs BB */
2388 rc = cifs_setup_session(xid, pSesInfo,
2389 cifs_sb->local_nls);
2390 up(&pSesInfo->sesSem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 }
Steve French50c2f752007-07-13 00:33:32 +00002392
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 /* search for existing tcon to this server share */
2394 if (!rc) {
Jeff Layton7586b762008-12-01 18:41:49 -05002395 setup_cifs_sb(volume_info, cifs_sb);
Steve French0ae0efa2005-10-10 10:57:19 -07002396
Jeff Layton7586b762008-12-01 18:41:49 -05002397 tcon = cifs_find_tcon(pSesInfo, volume_info->UNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 if (tcon) {
Steve Frenchbf820672005-12-01 22:32:42 -08002399 cFYI(1, ("Found match on UNC path"));
Jeff Laytonf1987b42008-11-15 11:12:47 -05002400 /* existing tcon already has a reference */
2401 cifs_put_smb_ses(pSesInfo);
Jeff Layton7586b762008-12-01 18:41:49 -05002402 if (tcon->seal != volume_info->seal)
Steve French95b1cb92008-05-15 16:44:38 +00002403 cERROR(1, ("transport encryption setting "
2404 "conflicts with existing tid"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 } else {
2406 tcon = tconInfoAlloc();
Steve French3b795212008-11-13 19:45:32 +00002407 if (tcon == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 rc = -ENOMEM;
Steve French3b795212008-11-13 19:45:32 +00002409 goto mount_fail_check;
2410 }
Jeff Layton00e485b2008-12-05 20:41:21 -05002411
Steve Frenchab3f9922008-11-17 16:03:00 +00002412 tcon->ses = pSesInfo;
Jeff Layton00e485b2008-12-05 20:41:21 -05002413 if (volume_info->password) {
2414 tcon->password = kstrdup(volume_info->password,
2415 GFP_KERNEL);
2416 if (!tcon->password) {
2417 rc = -ENOMEM;
2418 goto mount_fail_check;
2419 }
2420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
Jeff Layton7586b762008-12-01 18:41:49 -05002422 if ((strchr(volume_info->UNC + 3, '\\') == NULL)
2423 && (strchr(volume_info->UNC + 3, '/') == NULL)) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002424 cERROR(1, ("Missing share name"));
Steve French3b795212008-11-13 19:45:32 +00002425 rc = -ENODEV;
2426 goto mount_fail_check;
2427 } else {
2428 /* BB Do we need to wrap sesSem around
2429 * this TCon call and Unix SetFS as
2430 * we do on SessSetup and reconnect? */
Jeff Layton7586b762008-12-01 18:41:49 -05002431 rc = CIFSTCon(xid, pSesInfo, volume_info->UNC,
Steve French3b795212008-11-13 19:45:32 +00002432 tcon, cifs_sb->local_nls);
2433 cFYI(1, ("CIFS Tcon rc = %d", rc));
Jeff Layton7586b762008-12-01 18:41:49 -05002434 if (volume_info->nodfs) {
Steve French3b795212008-11-13 19:45:32 +00002435 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2436 cFYI(1, ("DFS disabled (%d)",
2437 tcon->Flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 }
2439 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002440 if (rc)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002441 goto remote_path_check;
Jeff Layton7586b762008-12-01 18:41:49 -05002442 tcon->seal = volume_info->seal;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002443 write_lock(&cifs_tcp_ses_lock);
2444 list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2445 write_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 }
Steve French3b795212008-11-13 19:45:32 +00002447
2448 /* we can have only one retry value for a connection
2449 to a share so for resources mounted more than once
2450 to the same server share the last value passed in
2451 for the retry flag is used */
Jeff Layton7586b762008-12-01 18:41:49 -05002452 tcon->retry = volume_info->retry;
2453 tcon->nocase = volume_info->nocase;
2454 tcon->local_lease = volume_info->local_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 }
Steve French4523cc32007-04-30 20:13:06 +00002456 if (pSesInfo) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2458 sb->s_maxbytes = (u64) 1 << 63;
2459 } else
2460 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2461 }
2462
Steve French8af18972007-02-14 04:42:51 +00002463 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 sb->s_time_gran = 100;
2465
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002466 if (rc)
2467 goto remote_path_check;
2468
Steve Frenchd82c2df2008-11-15 00:07:26 +00002469 cifs_sb->tcon = tcon;
Steve Frenchd82c2df2008-11-15 00:07:26 +00002470
2471 /* do not care if following two calls succeed - informational */
2472 if (!tcon->ipc) {
2473 CIFSSMBQFSDeviceInfo(xid, tcon);
2474 CIFSSMBQFSAttributeInfo(xid, tcon);
2475 }
2476
2477 /* tell server which Unix caps we support */
2478 if (tcon->ses->capabilities & CAP_UNIX)
2479 /* reset of caps checks mount to see if unix extensions
2480 disabled for just this mount */
Jeff Layton7586b762008-12-01 18:41:49 -05002481 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
Steve Frenchd82c2df2008-11-15 00:07:26 +00002482 else
2483 tcon->unix_ext = 0; /* server does not support them */
2484
2485 /* convert forward to back slashes in prepath here if needed */
2486 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2487 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2488
2489 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2490 cifs_sb->rsize = 1024 * 127;
2491 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2492 }
2493 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2494 cifs_sb->wsize = min(cifs_sb->wsize,
2495 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2496 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2497 cifs_sb->rsize = min(cifs_sb->rsize,
2498 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002500remote_path_check:
2501 /* check if a whole path (including prepath) is not remote */
2502 if (!rc && cifs_sb->prepathlen && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002503 /* build_path_to_root works only when we have a valid tcon */
2504 full_path = cifs_build_path_to_root(cifs_sb);
2505 if (full_path == NULL) {
2506 rc = -ENOMEM;
2507 goto mount_fail_check;
2508 }
2509 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002510 if (rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03002511 kfree(full_path);
2512 goto mount_fail_check;
2513 }
2514 kfree(full_path);
2515 }
2516
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002517 /* get referral if needed */
2518 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00002519#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002520 if (referral_walks_count > MAX_NESTED_LINKS) {
2521 /*
2522 * BB: when we implement proper loop detection,
2523 * we will remove this check. But now we need it
2524 * to prevent an indefinite loop if 'DFS tree' is
2525 * misconfigured (i.e. has loops).
2526 */
2527 rc = -ELOOP;
2528 goto mount_fail_check;
2529 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002530 /* convert forward to back slashes in prepath here if needed */
2531 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2532 convert_delimiter(cifs_sb->prepath,
2533 CIFS_DIR_SEP(cifs_sb));
2534 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2535 if (IS_ERR(full_path)) {
2536 rc = PTR_ERR(full_path);
2537 goto mount_fail_check;
2538 }
2539
2540 cFYI(1, ("Getting referral for: %s", full_path));
2541 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2542 cifs_sb->local_nls, &num_referrals, &referrals,
2543 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2544 if (!rc && num_referrals > 0) {
2545 char *fake_devname = NULL;
2546
2547 if (mount_data != mount_data_global)
2548 kfree(mount_data);
2549 mount_data = cifs_compose_mount_options(
2550 cifs_sb->mountdata, full_path + 1,
2551 referrals, &fake_devname);
2552 kfree(fake_devname);
2553 free_dfs_info_array(referrals, num_referrals);
2554
2555 if (tcon)
2556 cifs_put_tcon(tcon);
2557 else if (pSesInfo)
2558 cifs_put_smb_ses(pSesInfo);
2559
2560 cleanup_volume_info(&volume_info);
2561 FreeXid(xid);
2562 kfree(full_path);
Igor Mammedov5c2503a2009-04-21 19:31:05 +04002563 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002564 goto try_mount_again;
2565 }
Steve Frenchd036f502009-04-03 03:12:08 +00002566#else /* No DFS support, return error on mount */
2567 rc = -EOPNOTSUPP;
2568#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002569 }
2570
2571mount_fail_check:
2572 /* on error free sesinfo and tcon struct if needed */
2573 if (rc) {
2574 if (mount_data != mount_data_global)
2575 kfree(mount_data);
2576 /* If find_unc succeeded then rc == 0 so we can not end */
2577 /* up accidently freeing someone elses tcon struct */
2578 if (tcon)
2579 cifs_put_tcon(tcon);
2580 else if (pSesInfo)
2581 cifs_put_smb_ses(pSesInfo);
2582 else
2583 cifs_put_tcp_session(srvTcp);
2584 goto out;
2585 }
2586
Jeff Layton7586b762008-12-01 18:41:49 -05002587 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 (in which case it is not needed anymore) but when new sesion is created
2589 the password ptr is put in the new session structure (in which case the
2590 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002591out:
2592 /* zero out password before freeing */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002593 cleanup_volume_info(&volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 FreeXid(xid);
2595 return rc;
2596}
2597
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598int
2599CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2600 const char *tree, struct cifsTconInfo *tcon,
2601 const struct nls_table *nls_codepage)
2602{
2603 struct smb_hdr *smb_buffer;
2604 struct smb_hdr *smb_buffer_response;
2605 TCONX_REQ *pSMB;
2606 TCONX_RSP *pSMBr;
2607 unsigned char *bcc_ptr;
2608 int rc = 0;
Jeff Laytoncc20c032009-04-30 07:16:21 -04002609 int length, bytes_left;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 __u16 count;
2611
2612 if (ses == NULL)
2613 return -EIO;
2614
2615 smb_buffer = cifs_buf_get();
2616 if (smb_buffer == NULL) {
2617 return -ENOMEM;
2618 }
2619 smb_buffer_response = smb_buffer;
2620
2621 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2622 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07002623
2624 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 smb_buffer->Uid = ses->Suid;
2626 pSMB = (TCONX_REQ *) smb_buffer;
2627 pSMBr = (TCONX_RSP *) smb_buffer_response;
2628
2629 pSMB->AndXCommand = 0xFF;
2630 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002632 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08002633 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00002634 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08002635 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00002636 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08002637 } else {
Steve French7c7b25b2006-06-01 19:20:10 +00002638 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08002639 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2640 specified as required (when that support is added to
2641 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00002642 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08002643 by Samba (not sure whether other servers allow
2644 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00002645#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French50c2f752007-07-13 00:33:32 +00002646 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05002647 (ses->server->secType == LANMAN))
2648 calc_lanman_hash(tcon->password, ses->server->cryptKey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05002649 ses->server->secMode &
2650 SECMODE_PW_ENCRYPT ? true : false,
2651 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00002652 else
2653#endif /* CIFS_WEAK_PW_HASH */
Jeff Layton00e485b2008-12-05 20:41:21 -05002654 SMBNTencrypt(tcon->password, ses->server->cryptKey,
Steve Frencheeac8042006-01-13 21:34:58 -08002655 bcc_ptr);
2656
Steve French7c7b25b2006-06-01 19:20:10 +00002657 bcc_ptr += CIFS_SESS_KEY_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002658 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00002659 /* must align unicode strings */
2660 *bcc_ptr = 0; /* null byte password */
2661 bcc_ptr++;
2662 }
Steve Frencheeac8042006-01-13 21:34:58 -08002663 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664
Steve French50c2f752007-07-13 00:33:32 +00002665 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00002666 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2668
2669 if (ses->capabilities & CAP_STATUS32) {
2670 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2671 }
2672 if (ses->capabilities & CAP_DFS) {
2673 smb_buffer->Flags2 |= SMBFLG2_DFS;
2674 }
2675 if (ses->capabilities & CAP_UNICODE) {
2676 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2677 length =
Steve French50c2f752007-07-13 00:33:32 +00002678 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2679 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00002680 (/* server len*/ + 256 /* share len */), nls_codepage);
2681 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 bcc_ptr += 2; /* skip trailing null */
2683 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 strcpy(bcc_ptr, tree);
2685 bcc_ptr += strlen(tree) + 1;
2686 }
2687 strcpy(bcc_ptr, "?????");
2688 bcc_ptr += strlen("?????");
2689 bcc_ptr += 1;
2690 count = bcc_ptr - &pSMB->Password[0];
2691 pSMB->hdr.smb_buf_length += count;
2692 pSMB->ByteCount = cpu_to_le16(count);
2693
Steve French133672e2007-11-13 22:41:37 +00002694 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2695 CIFS_STD_OP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 /* above now done in SendReceive */
2698 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00002699 bool is_unicode;
2700
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00002702 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 tcon->tid = smb_buffer_response->Tid;
2704 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04002705 bytes_left = BCC(smb_buffer_response);
2706 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00002707 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
2708 is_unicode = true;
2709 else
2710 is_unicode = false;
2711
Jeff Laytoncc20c032009-04-30 07:16:21 -04002712
Steve French50c2f752007-07-13 00:33:32 +00002713 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00002714 if (length == 3) {
2715 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
2716 (bcc_ptr[2] == 'C')) {
2717 cFYI(1, ("IPC connection"));
2718 tcon->ipc = 1;
2719 }
2720 } else if (length == 2) {
2721 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
2722 /* the most common case */
2723 cFYI(1, ("disk share connection"));
2724 }
2725 }
Steve French50c2f752007-07-13 00:33:32 +00002726 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04002727 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04002729
2730 /* mostly informational -- no need to fail on error here */
Steve Frenchd185cda2009-04-30 17:45:10 +00002731 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00002732 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04002733 nls_codepage);
2734
2735 cFYI(1, ("nativeFileSystem=%s", tcon->nativeFileSystem));
2736
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002737 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00002738 (smb_buffer_response->WordCount == 7))
2739 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00002740 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
2741 else
2742 tcon->Flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
2744 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002745 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 ses->ipc_tid = smb_buffer_response->Tid;
2747 }
2748
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00002749 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 return rc;
2751}
2752
2753int
2754cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
2755{
2756 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00002757 char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758
Jeff Laytonf1987b42008-11-15 11:12:47 -05002759 if (cifs_sb->tcon)
2760 cifs_put_tcon(cifs_sb->tcon);
Steve French50c2f752007-07-13 00:33:32 +00002761
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 cifs_sb->tcon = NULL;
Steve French2fe87f02006-09-21 07:02:52 +00002763 tmp = cifs_sb->prepath;
2764 cifs_sb->prepathlen = 0;
2765 cifs_sb->prepath = NULL;
2766 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767
Steve French88e7d702008-01-03 17:37:09 +00002768 return rc;
Steve French50c2f752007-07-13 00:33:32 +00002769}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770
2771int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
Steve French50c2f752007-07-13 00:33:32 +00002772 struct nls_table *nls_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773{
2774 int rc = 0;
Steve Frenchad009ac2005-04-28 22:41:05 -07002775 int first_time = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002776 struct TCP_Server_Info *server = pSesInfo->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777
2778 /* what if server changes its buffer size after dropping the session? */
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002779 if (server->maxBuf == 0) /* no need to send on reconnect */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 rc = CIFSSMBNegotiate(xid, pSesInfo);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002781 if (rc == -EAGAIN) {
2782 /* retry only once on 1st time connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 rc = CIFSSMBNegotiate(xid, pSesInfo);
Steve French50c2f752007-07-13 00:33:32 +00002784 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 rc = -EHOSTDOWN;
2786 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002787 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 spin_lock(&GlobalMid_Lock);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002789 if (server->tcpStatus != CifsExiting)
2790 server->tcpStatus = CifsGood;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 else
2792 rc = -EHOSTDOWN;
2793 spin_unlock(&GlobalMid_Lock);
2794
2795 }
Steve Frenchad009ac2005-04-28 22:41:05 -07002796 first_time = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 }
Steve French26b994f2008-08-06 05:11:33 +00002798
2799 if (rc)
2800 goto ss_err_exit;
2801
2802 pSesInfo->flags = 0;
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002803 pSesInfo->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00002804 if (linuxExtEnabled == 0)
2805 pSesInfo->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00002806
Steve French26b994f2008-08-06 05:11:33 +00002807 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
Jeff Laytoncb7691b2008-08-18 15:41:05 -04002808 server->secMode, server->capabilities, server->timeAdj));
2809
Steve French20418ac2009-04-30 16:13:32 +00002810 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00002811 if (rc) {
2812 cERROR(1, ("Send error in SessSetup = %d", rc));
2813 } else {
2814 cFYI(1, ("CIFS Session Established successfully"));
Steve French20418ac2009-04-30 16:13:32 +00002815 spin_lock(&GlobalMid_Lock);
2816 pSesInfo->status = CifsGood;
2817 pSesInfo->need_reconnect = false;
2818 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00002819 }
2820
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821ss_err_exit:
2822 return rc;
2823}
2824