blob: 261ca81d5e49668bc6f1ba8868b4d01d4cd3be2d [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090026#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070031#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070032#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000033#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070034#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040036#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/uaccess.h>
38#include <asm/processor.h>
Jeff Layton50b64e32009-06-02 06:55:20 -040039#include <linux/inet.h>
Steve French0e2beda2009-01-30 21:24:41 +000040#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "cifspdu.h"
42#include "cifsglob.h"
43#include "cifsproto.h"
44#include "cifs_unicode.h"
45#include "cifs_debug.h"
46#include "cifs_fs_sb.h"
47#include "ntlmssp.h"
48#include "nterr.h"
49#include "rfc1002pdu.h"
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +053050#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52#define CIFS_PORT 445
53#define RFC1001_PORT 139
54
Jeff Laytonc74093b2011-01-11 07:24:23 -050055/* SMB echo "timeout" -- FIXME: tunable? */
56#define SMB_ECHO_INTERVAL (60 * HZ)
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058extern mempool_t *cifs_req_poolp;
59
Jeff Layton2de970f2010-10-06 19:51:12 -040060/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -040061#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -040062#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -040063
Pavel Shilovskya9f1b852010-12-13 19:08:35 +030064static int ip_connect(struct TCP_Server_Info *server);
65static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -040066static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -040067static void cifs_prune_tlinks(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Jeff Laytond5c56052008-12-01 18:42:33 -050069/*
70 * cifs tcp session reconnection
71 *
72 * mark tcp session as reconnecting so temporarily locked
73 * mark all smb sessions as reconnecting for tcp session
74 * reconnect tcp session
75 * wake up waiters on reconnection? - (not needed currently)
76 */
Steve French2cd646a2006-09-28 19:43:08 +000077static int
Linus Torvalds1da177e2005-04-16 15:20:36 -070078cifs_reconnect(struct TCP_Server_Info *server)
79{
80 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -050081 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 struct cifsSesInfo *ses;
83 struct cifsTconInfo *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +000084 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -040085 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +000086
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +000088 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +000089 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 next time through the loop */
91 spin_unlock(&GlobalMid_Lock);
92 return rc;
93 } else
94 server->tcpStatus = CifsNeedReconnect;
95 spin_unlock(&GlobalMid_Lock);
96 server->maxBuf = 0;
97
Joe Perchesb6b38f72010-04-21 03:50:45 +000098 cFYI(1, "Reconnecting tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100 /* before reconnecting the tcp session, mark the smb session (uid)
101 and the tid bad so they are not used until reconnected */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500102 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530103 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500104 list_for_each(tmp, &server->smb_ses_list) {
105 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
106 ses->need_reconnect = true;
107 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500108 list_for_each(tmp2, &ses->tcon_list) {
109 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
110 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530113 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 /* do not want to be sending data on a socket we are freeing */
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500116 cFYI(1, "%s: tearing down socket", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500117 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000118 if (server->ssocket) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000119 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
120 server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800121 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000122 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
Steve French467a8f82007-06-27 22:41:32 +0000123 server->ssocket->state,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000124 server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 sock_release(server->ssocket);
126 server->ssocket = NULL;
127 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500128 server->sequence_number = 0;
129 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500130 kfree(server->session_key.response);
131 server->session_key.response = NULL;
132 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000133 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500134 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500136 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400137 INIT_LIST_HEAD(&retry_list);
138 cFYI(1, "%s: moving mids to private list", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500140 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
141 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
142 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
Steve Frenchad8b15f2008-08-08 21:10:16 +0000143 mid_entry->midState = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400144 list_move(&mid_entry->qhead, &retry_list);
145 }
146 spin_unlock(&GlobalMid_Lock);
147
148 cFYI(1, "%s: issuing mid callbacks", __func__);
149 list_for_each_safe(tmp, tmp2, &retry_list) {
150 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500151 list_del_init(&mid_entry->qhead);
152 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Steve Frenchfd88ce92011-04-12 01:01:14 +0000155 while (server->tcpStatus == CifsNeedReconnect) {
Steve French6c3d8902006-07-31 22:46:20 +0000156 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300157
158 /* we should try only the port we connected to before */
159 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000160 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000161 cFYI(1, "reconnect error %d", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700162 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 } else {
164 atomic_inc(&tcpSesReconnectCount);
165 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000166 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000167 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000168 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 }
170 }
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return rc;
173}
174
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000175/*
Steve Frenche4eb2952005-04-28 22:41:09 -0700176 return codes:
177 0 not a transact2, or all data present
178 >0 transact2 with that much data missing
179 -EINVAL = invalid transact2
180
181 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000182static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
Steve Frenche4eb2952005-04-28 22:41:09 -0700183{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000184 struct smb_t2_rsp *pSMBt;
Steve Frenche4eb2952005-04-28 22:41:09 -0700185 int remaining;
Jeff Layton26ec2542011-01-20 13:36:51 -0500186 __u16 total_data_size, data_in_this_rsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700187
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000188 if (pSMB->Command != SMB_COM_TRANSACTION2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700189 return 0;
190
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000191 /* check for plausible wct, bcc and t2 data and parm sizes */
192 /* check for parm and data offset going beyond end of smb */
193 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000194 cFYI(1, "invalid transact2 word count");
Steve Frenche4eb2952005-04-28 22:41:09 -0700195 return -EINVAL;
196 }
197
198 pSMBt = (struct smb_t2_rsp *)pSMB;
199
Jeff Layton26ec2542011-01-20 13:36:51 -0500200 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
201 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700202
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400203 if (total_data_size == data_in_this_rsp)
Steve Frenche4eb2952005-04-28 22:41:09 -0700204 return 0;
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400205 else if (total_data_size < data_in_this_rsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000206 cFYI(1, "total data %d smaller than data in frame %d",
207 total_data_size, data_in_this_rsp);
Steve Frenche4eb2952005-04-28 22:41:09 -0700208 return -EINVAL;
Steve Frenche4eb2952005-04-28 22:41:09 -0700209 }
Jeff Laytonc0c7b902011-03-31 17:32:54 -0400210
211 remaining = total_data_size - data_in_this_rsp;
212
213 cFYI(1, "missing %d bytes from transact2, check next response",
214 remaining);
215 if (total_data_size > maxBufSize) {
216 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
217 total_data_size, maxBufSize);
218 return -EINVAL;
219 }
220 return remaining;
Steve Frenche4eb2952005-04-28 22:41:09 -0700221}
222
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000223static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
Steve Frenche4eb2952005-04-28 22:41:09 -0700224{
225 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
226 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000227 char *data_area_of_target;
228 char *data_area_of_buf2;
Jeff Layton26ec2542011-01-20 13:36:51 -0500229 int remaining;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400230 unsigned int byte_count, total_in_buf;
231 __u16 total_data_size, total_in_buf2;
Steve Frenche4eb2952005-04-28 22:41:09 -0700232
Jeff Layton26ec2542011-01-20 13:36:51 -0500233 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700234
Jeff Layton26ec2542011-01-20 13:36:51 -0500235 if (total_data_size !=
236 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000237 cFYI(1, "total data size of primary and secondary t2 differ");
Steve Frenche4eb2952005-04-28 22:41:09 -0700238
Jeff Layton26ec2542011-01-20 13:36:51 -0500239 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
Steve Frenche4eb2952005-04-28 22:41:09 -0700240
241 remaining = total_data_size - total_in_buf;
Steve French50c2f752007-07-13 00:33:32 +0000242
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000243 if (remaining < 0)
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400244 return -EPROTO;
Steve Frenche4eb2952005-04-28 22:41:09 -0700245
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000246 if (remaining == 0) /* nothing to do, ignore */
Steve Frenche4eb2952005-04-28 22:41:09 -0700247 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000248
Jeff Layton26ec2542011-01-20 13:36:51 -0500249 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000250 if (remaining < total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000251 cFYI(1, "transact2 2nd response contains too much data");
Steve Frenche4eb2952005-04-28 22:41:09 -0700252 }
253
254 /* find end of first SMB data area */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000255 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
Jeff Layton26ec2542011-01-20 13:36:51 -0500256 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700257 /* validate target area */
258
Jeff Layton26ec2542011-01-20 13:36:51 -0500259 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
260 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
Steve Frenche4eb2952005-04-28 22:41:09 -0700261
262 data_area_of_target += total_in_buf;
263
264 /* copy second buffer into end of first buffer */
Steve Frenche4eb2952005-04-28 22:41:09 -0700265 total_in_buf += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400266 /* is the result too big for the field? */
267 if (total_in_buf > USHRT_MAX)
268 return -EPROTO;
Jeff Layton26ec2542011-01-20 13:36:51 -0500269 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400270
271 /* fix up the BCC */
Jeff Layton820a8032011-05-04 08:05:26 -0400272 byte_count = get_bcc(pTargetSMB);
Steve Frenche4eb2952005-04-28 22:41:09 -0700273 byte_count += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400274 /* is the result too big for the field? */
275 if (byte_count > USHRT_MAX)
276 return -EPROTO;
Jeff Layton820a8032011-05-04 08:05:26 -0400277 put_bcc(byte_count, pTargetSMB);
Steve Frenche4eb2952005-04-28 22:41:09 -0700278
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000279 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
Steve Frenche4eb2952005-04-28 22:41:09 -0700280 byte_count += total_in_buf2;
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400281 /* don't allow buffer to overflow */
282 if (byte_count > CIFSMaxBufSize)
283 return -ENOBUFS;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000284 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
Steve Frenche4eb2952005-04-28 22:41:09 -0700285
Jeff Layton2a2047bc2011-04-27 13:29:49 -0400286 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
287
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000288 if (remaining == total_in_buf2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000289 cFYI(1, "found the last secondary response");
Steve Frenche4eb2952005-04-28 22:41:09 -0700290 return 0; /* we are done */
291 } else /* more responses to go */
292 return 1;
Steve Frenche4eb2952005-04-28 22:41:09 -0700293}
294
Jeff Laytonc74093b2011-01-11 07:24:23 -0500295static void
296cifs_echo_request(struct work_struct *work)
297{
298 int rc;
299 struct TCP_Server_Info *server = container_of(work,
300 struct TCP_Server_Info, echo.work);
301
Jeff Layton247ec9b2011-02-04 17:09:50 -0500302 /*
Jeff Layton195291e2011-02-09 12:01:42 -0500303 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
304 * done, which is indicated by maxBuf != 0. Also, no need to ping if
305 * we got a response recently
Jeff Layton247ec9b2011-02-04 17:09:50 -0500306 */
Jeff Layton195291e2011-02-09 12:01:42 -0500307 if (server->maxBuf == 0 ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500308 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500309 goto requeue_echo;
310
311 rc = CIFSSMBEcho(server);
312 if (rc)
313 cFYI(1, "Unable to send echo request to server: %s",
314 server->hostname);
315
316requeue_echo:
317 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
318}
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320static int
321cifs_demultiplex_thread(struct TCP_Server_Info *server)
322{
323 int length;
324 unsigned int pdu_length, total_read;
325 struct smb_hdr *smb_buffer = NULL;
Steve Frenchb8643e12005-04-28 22:41:07 -0700326 struct smb_hdr *bigbuf = NULL;
327 struct smb_hdr *smallbuf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 struct msghdr smb_msg;
329 struct kvec iov;
330 struct socket *csocket = server->ssocket;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500331 struct list_head *tmp, *tmp2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 struct task_struct *task_to_wake = NULL;
333 struct mid_q_entry *mid_entry;
Steve French70ca7342005-09-22 16:32:06 -0700334 char temp;
Steve French4b18f2a2008-04-29 00:06:05 +0000335 bool isLargeBuf = false;
336 bool isMultiRsp;
Steve Frenche4eb2952005-04-28 22:41:09 -0700337 int reconnect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 current->flags |= PF_MEMALLOC;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000340 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400341
342 length = atomic_inc_return(&tcpSesAllocCount);
343 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000344 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
345 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700347 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000348 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700349 if (try_to_freeze())
350 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700351 if (bigbuf == NULL) {
352 bigbuf = cifs_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000353 if (!bigbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000354 cERROR(1, "No memory for large SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700355 msleep(3000);
356 /* retry will check if exiting */
357 continue;
358 }
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000359 } else if (isLargeBuf) {
360 /* we are reusing a dirty large buf, clear its start */
Steve French26f57362007-08-30 22:09:15 +0000361 memset(bigbuf, 0, sizeof(struct smb_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
Steve Frenchb8643e12005-04-28 22:41:07 -0700363
364 if (smallbuf == NULL) {
365 smallbuf = cifs_small_buf_get();
Pavel Machek0fd1ffe2006-06-13 21:31:39 +0000366 if (!smallbuf) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000367 cERROR(1, "No memory for SMB response");
Steve Frenchb8643e12005-04-28 22:41:07 -0700368 msleep(1000);
369 /* retry will check if exiting */
370 continue;
371 }
372 /* beginning of smb buffer is cleared in our buf_get */
373 } else /* if existing small buf clear beginning */
Steve French26f57362007-08-30 22:09:15 +0000374 memset(smallbuf, 0, sizeof(struct smb_hdr));
Steve Frenchb8643e12005-04-28 22:41:07 -0700375
Steve French4b18f2a2008-04-29 00:06:05 +0000376 isLargeBuf = false;
377 isMultiRsp = false;
Steve Frenchb8643e12005-04-28 22:41:07 -0700378 smb_buffer = smallbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 iov.iov_base = smb_buffer;
380 iov.iov_len = 4;
381 smb_msg.msg_control = NULL;
382 smb_msg.msg_controllen = 0;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000383 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000384
Steve Frenchf01d5e12007-08-30 21:13:31 +0000385incomplete_rcv:
Steve Frenchfd88ce92011-04-12 01:01:14 +0000386 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
Steve Frenchfda35942011-01-20 18:06:34 +0000387 time_after(jiffies, server->lstrp +
388 (echo_retries * SMB_ECHO_INTERVAL))) {
389 cERROR(1, "Server %s has not responded in %d seconds. "
390 "Reconnecting...", server->hostname,
391 (echo_retries * SMB_ECHO_INTERVAL / HZ));
392 cifs_reconnect(server);
393 csocket = server->ssocket;
394 wake_up(&server->response_q);
395 continue;
396 }
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 length =
399 kernel_recvmsg(csocket, &smb_msg,
Steve Frenchf01d5e12007-08-30 21:13:31 +0000400 &iov, 1, pdu_length, 0 /* BB other flags? */);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Jeff Layton469ee612008-10-16 18:46:39 +0000402 if (server->tcpStatus == CifsExiting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 break;
404 } else if (server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000405 cFYI(1, "Reconnect after server stopped responding");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 cifs_reconnect(server);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000407 cFYI(1, "call to reconnect done");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 csocket = server->ssocket;
409 continue;
Jeff Layton522bbe62010-09-03 12:00:49 -0400410 } else if (length == -ERESTARTSYS ||
411 length == -EAGAIN ||
412 length == -EINTR) {
Steve Frenchb8643e12005-04-28 22:41:07 -0700413 msleep(1); /* minimum sleep to prevent looping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 allowing socket to clear and app threads to set
415 tcpStatus CifsNeedReconnect if server hung */
Steve Frenchc527c8a2008-11-03 20:46:21 +0000416 if (pdu_length < 4) {
417 iov.iov_base = (4 - pdu_length) +
418 (char *)smb_buffer;
419 iov.iov_len = pdu_length;
420 smb_msg.msg_control = NULL;
421 smb_msg.msg_controllen = 0;
Steve Frenchc18c7322007-10-17 18:01:11 +0000422 goto incomplete_rcv;
Steve Frenchc527c8a2008-11-03 20:46:21 +0000423 } else
Steve Frenchc18c7322007-10-17 18:01:11 +0000424 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000426 cFYI(1, "Reconnect after unexpected peek error %d",
427 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 cifs_reconnect(server);
429 csocket = server->ssocket;
430 wake_up(&server->response_q);
431 continue;
Petr Tesarik2a974682007-11-20 02:24:08 +0000432 } else if (length < pdu_length) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000433 cFYI(1, "requested %d bytes but only got %d bytes",
434 pdu_length, length);
Steve Frenchf01d5e12007-08-30 21:13:31 +0000435 pdu_length -= length;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000436 msleep(1);
437 goto incomplete_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
Steve French67010fb2005-04-28 22:41:09 -0700439
Steve French70ca7342005-09-22 16:32:06 -0700440 /* The right amount was read from socket - 4 bytes */
441 /* so we can now interpret the length field */
Steve French46810cb2005-04-28 22:41:09 -0700442
Steve French70ca7342005-09-22 16:32:06 -0700443 /* the first byte big endian of the length field,
444 is actually not part of the length but the type
445 with the most common, zero, as regular data */
446 temp = *((char *) smb_buffer);
447
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000448 /* Note that FC 1001 length is big endian on the wire,
Steve French70ca7342005-09-22 16:32:06 -0700449 but we convert it here so it is always manipulated
450 as host byte order */
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000451 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
Steve French46810cb2005-04-28 22:41:09 -0700452
Joe Perchesb6b38f72010-04-21 03:50:45 +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) {
Joe Perchesb6b38f72010-04-21 03:50:45 +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 */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000463 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
464 pdu_length);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400465 /* give server a second to clean up */
466 msleep(1000);
467 /* always try 445 first on reconnect since we get NACK
468 * on some if we ever connected to port 139 (the NACK
469 * is since we do not begin with RFC1001 session
470 * initialize frame)
471 */
Jeff Layton32670392010-09-03 12:00:50 -0400472 cifs_set_port((struct sockaddr *)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300473 &server->dstaddr, CIFS_PORT);
Jeff Layton7332f2a2010-09-03 12:00:49 -0400474 cifs_reconnect(server);
475 csocket = server->ssocket;
476 wake_up(&server->response_q);
477 continue;
Steve French70ca7342005-09-22 16:32:06 -0700478 } else if (temp != (char) 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000479 cERROR(1, "Unknown RFC 1002 frame");
Steve French70ca7342005-09-22 16:32:06 -0700480 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
481 length);
Steve French46810cb2005-04-28 22:41:09 -0700482 cifs_reconnect(server);
483 csocket = server->ssocket;
484 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700485 }
486
487 /* else we have an SMB response */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000488 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
Steve French26f57362007-08-30 22:09:15 +0000489 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000490 cERROR(1, "Invalid size SMB length %d pdu_length %d",
491 length, pdu_length+4);
Steve Frenche4eb2952005-04-28 22:41:09 -0700492 cifs_reconnect(server);
493 csocket = server->ssocket;
494 wake_up(&server->response_q);
495 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000496 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700497
498 /* else length ok */
499 reconnect = 0;
500
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000501 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
Steve French4b18f2a2008-04-29 00:06:05 +0000502 isLargeBuf = true;
Steve Frenche4eb2952005-04-28 22:41:09 -0700503 memcpy(bigbuf, smallbuf, 4);
504 smb_buffer = bigbuf;
505 }
506 length = 0;
507 iov.iov_base = 4 + (char *)smb_buffer;
508 iov.iov_len = pdu_length;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000509 for (total_read = 0; total_read < pdu_length;
Steve Frenche4eb2952005-04-28 22:41:09 -0700510 total_read += length) {
511 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
512 pdu_length - total_read, 0);
Jeff Layton522bbe62010-09-03 12:00:49 -0400513 if (server->tcpStatus == CifsExiting) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700514 /* then will exit */
515 reconnect = 2;
516 break;
517 } else if (server->tcpStatus == CifsNeedReconnect) {
Steve French46810cb2005-04-28 22:41:09 -0700518 cifs_reconnect(server);
519 csocket = server->ssocket;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000520 /* Reconnect wakes up rspns q */
Steve Frenche4eb2952005-04-28 22:41:09 -0700521 /* Now we will reread sock */
522 reconnect = 1;
523 break;
Jeff Layton522bbe62010-09-03 12:00:49 -0400524 } else if (length == -ERESTARTSYS ||
525 length == -EAGAIN ||
526 length == -EINTR) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700527 msleep(1); /* minimum sleep to prevent looping,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000528 allowing socket to clear and app
Steve Frenche4eb2952005-04-28 22:41:09 -0700529 threads to set tcpStatus
530 CifsNeedReconnect if server hung*/
Steve Frenchc18c7322007-10-17 18:01:11 +0000531 length = 0;
Steve French46810cb2005-04-28 22:41:09 -0700532 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700533 } else if (length <= 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000534 cERROR(1, "Received no data, expecting %d",
535 pdu_length - total_read);
Steve Frenche4eb2952005-04-28 22:41:09 -0700536 cifs_reconnect(server);
537 csocket = server->ssocket;
538 reconnect = 1;
539 break;
Steve French46810cb2005-04-28 22:41:09 -0700540 }
541 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000542 if (reconnect == 2)
Steve Frenche4eb2952005-04-28 22:41:09 -0700543 break;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000544 else if (reconnect == 1)
Steve Frenche4eb2952005-04-28 22:41:09 -0700545 continue;
546
Jeff Layton9587fcf2011-02-01 08:40:43 -0500547 total_read += 4; /* account for rfc1002 hdr */
Steve French50c2f752007-07-13 00:33:32 +0000548
Jeff Layton9587fcf2011-02-01 08:40:43 -0500549 dump_smb(smb_buffer, total_read);
Jeff Layton71823ba2011-02-10 08:03:50 -0500550
551 /*
552 * We know that we received enough to get to the MID as we
553 * checked the pdu_length earlier. Now check to see
554 * if the rest of the header is OK. We borrow the length
555 * var for the rest of the loop to avoid a new stack var.
556 *
557 * 48 bytes is enough to display the header and a little bit
558 * into the payload for debugging purposes.
559 */
560 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
561 if (length != 0)
Jeff Layton9587fcf2011-02-01 08:40:43 -0500562 cifs_dump_mem("Bad SMB: ", smb_buffer,
Jeff Layton71823ba2011-02-10 08:03:50 -0500563 min_t(unsigned int, total_read, 48));
Steve Frenche4eb2952005-04-28 22:41:09 -0700564
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500565 mid_entry = NULL;
Steve Frenchfda35942011-01-20 18:06:34 +0000566 server->lstrp = jiffies;
567
Steve Frenche4eb2952005-04-28 22:41:09 -0700568 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500569 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
Steve Frenche4eb2952005-04-28 22:41:09 -0700570 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
571
Jeff Layton146f9f62011-04-29 06:52:43 -0400572 if (mid_entry->mid != smb_buffer->Mid ||
573 mid_entry->midState != MID_REQUEST_SUBMITTED ||
574 mid_entry->command != smb_buffer->Command) {
575 mid_entry = NULL;
576 continue;
577 }
578
579 if (length == 0 &&
580 check2ndT2(smb_buffer, server->maxBuf) > 0) {
581 /* We have a multipart transact2 resp */
582 isMultiRsp = true;
583 if (mid_entry->resp_buf) {
584 /* merge response - fix up 1st*/
Jeff Layton16541ba2011-04-29 06:52:44 -0400585 length = coalesce_t2(smb_buffer,
586 mid_entry->resp_buf);
587 if (length > 0) {
588 length = 0;
Jeff Layton146f9f62011-04-29 06:52:43 -0400589 mid_entry->multiRsp = true;
590 break;
Steve Frenche4eb2952005-04-28 22:41:09 -0700591 } else {
Jeff Layton16541ba2011-04-29 06:52:44 -0400592 /* all parts received or
593 * packet is malformed
594 */
Jeff Layton146f9f62011-04-29 06:52:43 -0400595 mid_entry->multiEnd = true;
596 goto multi_t2_fnd;
Steve Frenche4eb2952005-04-28 22:41:09 -0700597 }
Jeff Layton146f9f62011-04-29 06:52:43 -0400598 } else {
599 if (!isLargeBuf) {
600 /*
601 * FIXME: switch to already
602 * allocated largebuf?
603 */
604 cERROR(1, "1st trans2 resp "
605 "needs bigbuf");
606 } else {
607 /* Have first buffer */
608 mid_entry->resp_buf =
609 smb_buffer;
610 mid_entry->largeBuf = true;
611 bigbuf = NULL;
612 }
Steve French50c2f752007-07-13 00:33:32 +0000613 }
Steve Frenche4eb2952005-04-28 22:41:09 -0700614 break;
615 }
Jeff Layton146f9f62011-04-29 06:52:43 -0400616 mid_entry->resp_buf = smb_buffer;
617 mid_entry->largeBuf = isLargeBuf;
618multi_t2_fnd:
619 if (length == 0)
620 mid_entry->midState = MID_RESPONSE_RECEIVED;
621 else
622 mid_entry->midState = MID_RESPONSE_MALFORMED;
623#ifdef CONFIG_CIFS_STATS2
624 mid_entry->when_received = jiffies;
625#endif
626 list_del_init(&mid_entry->qhead);
Jeff Layton146f9f62011-04-29 06:52:43 -0400627 break;
Steve Frenche4eb2952005-04-28 22:41:09 -0700628 }
629 spin_unlock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500630
631 if (mid_entry != NULL) {
Jeff Layton3c1105d2011-05-22 07:09:13 -0400632 mid_entry->callback(mid_entry);
Steve Frenchcd634992005-04-28 22:41:10 -0700633 /* Was previous buf put in mpx struct for multi-rsp? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000634 if (!isMultiRsp) {
Steve Frenchcd634992005-04-28 22:41:10 -0700635 /* smb buffer will be freed by user thread */
Steve French26f57362007-08-30 22:09:15 +0000636 if (isLargeBuf)
Steve Frenchcd634992005-04-28 22:41:10 -0700637 bigbuf = NULL;
Steve French26f57362007-08-30 22:09:15 +0000638 else
Steve Frenchcd634992005-04-28 22:41:10 -0700639 smallbuf = NULL;
640 }
Jeff Layton71823ba2011-02-10 08:03:50 -0500641 } else if (length != 0) {
642 /* response sanity checks failed */
643 continue;
Steve French4b18f2a2008-04-29 00:06:05 +0000644 } else if (!is_valid_oplock_break(smb_buffer, server) &&
645 !isMultiRsp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000646 cERROR(1, "No task to wake, unknown frame received! "
Jeff Layton80975312011-01-11 07:24:02 -0500647 "NumMids %d", atomic_read(&midCount));
Steve French50c2f752007-07-13 00:33:32 +0000648 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
Steve French70ca7342005-09-22 16:32:06 -0700649 sizeof(struct smb_hdr));
Steve French39798772006-05-31 22:40:51 +0000650#ifdef CONFIG_CIFS_DEBUG2
651 cifs_dump_detail(smb_buffer);
652 cifs_dump_mids(server);
653#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000654
Steve Frenche4eb2952005-04-28 22:41:09 -0700655 }
656 } /* end while !EXITING */
657
Jeff Laytone7ddee92008-11-14 13:44:38 -0500658 /* take it off the list, if it's not already */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530659 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500660 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530661 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 spin_lock(&GlobalMid_Lock);
664 server->tcpStatus = CifsExiting;
Steve Frenche691b9d2008-05-11 15:53:33 +0000665 spin_unlock(&GlobalMid_Lock);
Steve Frenchdbdbb872008-06-10 21:21:56 +0000666 wake_up_all(&server->response_q);
Steve Frenche691b9d2008-05-11 15:53:33 +0000667
Steve French31ca3bc2005-04-28 22:41:11 -0700668 /* check if we have blocked requests that need to free */
669 /* Note that cifs_max_pending is normally 50, but
670 can be set at module install time to as little as two */
Steve Frenche691b9d2008-05-11 15:53:33 +0000671 spin_lock(&GlobalMid_Lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000672 if (atomic_read(&server->inFlight) >= cifs_max_pending)
Steve French31ca3bc2005-04-28 22:41:11 -0700673 atomic_set(&server->inFlight, cifs_max_pending - 1);
674 /* We do not want to set the max_pending too low or we
675 could end up with the counter going negative */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 spin_unlock(&GlobalMid_Lock);
Steve French50c2f752007-07-13 00:33:32 +0000677 /* Although there should not be any requests blocked on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 this queue it can not hurt to be paranoid and try to wake up requests
Steve French09d1db52005-04-28 22:41:08 -0700679 that may haven been blocked when more than 50 at time were on the wire
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 to the same server - they now will see the session is in exit state
681 and get out of SendReceive. */
682 wake_up_all(&server->request_q);
683 /* give those requests time to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700684 msleep(125);
Steve French50c2f752007-07-13 00:33:32 +0000685
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000686 if (server->ssocket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 sock_release(csocket);
688 server->ssocket = NULL;
689 }
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800690 /* buffer usually freed in free_mid - need to free it here on exit */
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +0000691 cifs_buf_release(bigbuf);
692 if (smallbuf) /* no sense logging a debug message if NULL */
Steve Frenchb8643e12005-04-28 22:41:07 -0700693 cifs_small_buf_release(smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Jeff Layton9d783152011-01-11 07:24:01 -0500695 if (!list_empty(&server->pending_mid_q)) {
Jeff Layton3c1105d2011-05-22 07:09:13 -0400696 struct list_head dispose_list;
697
698 INIT_LIST_HEAD(&dispose_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500700 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
Jeff Layton9d783152011-01-11 07:24:01 -0500701 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400702 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
703 mid_entry->midState = MID_SHUTDOWN;
704 list_move(&mid_entry->qhead, &dispose_list);
705 }
706 spin_unlock(&GlobalMid_Lock);
707
708 /* now walk dispose list and issue callbacks */
709 list_for_each_safe(tmp, tmp2, &dispose_list) {
710 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
711 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500712 list_del_init(&mid_entry->qhead);
713 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 /* 1/8th of sec is more than enough time for them to exit */
Steve Frenchb8643e12005-04-28 22:41:07 -0700716 msleep(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 }
718
Steve Frenchf1914012005-08-18 09:37:34 -0700719 if (!list_empty(&server->pending_mid_q)) {
Steve French50c2f752007-07-13 00:33:32 +0000720 /* mpx threads have not exited yet give them
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 at least the smb send timeout time for long ops */
Steve French31ca3bc2005-04-28 22:41:11 -0700722 /* due to delays on oplock break requests, we need
723 to wait at least 45 seconds before giving up
724 on a request getting a response and going ahead
725 and killing cifsd */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000726 cFYI(1, "Wait for exit from demultiplex thread");
Steve French31ca3bc2005-04-28 22:41:11 -0700727 msleep(46000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 /* if threads still have not exited they are probably never
729 coming home not much else we can do but free the memory */
730 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Jeff Laytonc359cf32007-11-16 22:22:06 +0000732 kfree(server->hostname);
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400733 task_to_wake = xchg(&server->tsk, NULL);
Steve French31ca3bc2005-04-28 22:41:11 -0700734 kfree(server);
Jeff Layton93d0ec82008-08-02 08:00:48 -0400735
736 length = atomic_dec_return(&tcpSesAllocCount);
Steve French26f57362007-08-30 22:09:15 +0000737 if (length > 0)
738 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
739 GFP_KERNEL);
Steve French50c2f752007-07-13 00:33:32 +0000740
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400741 /* if server->tsk was NULL then wait for a signal before exiting */
742 if (!task_to_wake) {
743 set_current_state(TASK_INTERRUPTIBLE);
744 while (!signal_pending(current)) {
745 schedule();
746 set_current_state(TASK_INTERRUPTIBLE);
747 }
748 set_current_state(TASK_RUNNING);
749 }
750
Jeff Layton0468a2c2008-12-01 07:09:35 -0500751 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752}
753
Jeff Laytonc359cf32007-11-16 22:22:06 +0000754/* extract the host portion of the UNC string */
755static char *
756extract_hostname(const char *unc)
757{
758 const char *src;
759 char *dst, *delim;
760 unsigned int len;
761
762 /* skip double chars at beginning of string */
763 /* BB: check validity of these bytes? */
764 src = unc + 2;
765
766 /* delimiter between hostname and sharename is always '\\' now */
767 delim = strchr(src, '\\');
768 if (!delim)
769 return ERR_PTR(-EINVAL);
770
771 len = delim - src;
772 dst = kmalloc((len + 1), GFP_KERNEL);
773 if (dst == NULL)
774 return ERR_PTR(-ENOMEM);
775
776 memcpy(dst, src, len);
777 dst[len] = '\0';
778
779 return dst;
780}
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782static int
Sean Finneyb9468452011-04-11 13:19:32 +0000783cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +0000784 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400786 char *value, *data, *end;
Sean Finneyb9468452011-04-11 13:19:32 +0000787 char *mountdata_copy, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 unsigned int temp_len, i, j;
789 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -0400790 short int override_uid = -1;
791 short int override_gid = -1;
792 bool uid_specified = false;
793 bool gid_specified = false;
Jeff Layton88463992010-11-22 15:31:03 -0500794 char *nodename = utsname()->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
796 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +0000797 separator[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Jeff Layton88463992010-11-22 15:31:03 -0500799 /*
800 * does not have to be perfect mapping since field is
801 * informational, only used for servers that do not support
802 * port 445 and it can be overridden at mount time
803 */
Jeff Layton1397f2e2011-01-07 11:30:28 -0500804 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
805 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -0500806 vol->source_rfc1001_name[i] = toupper(nodename[i]);
807
Jeff Layton1397f2e2011-01-07 11:30:28 -0500808 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -0700809 /* null target name indicates to use *SMBSERVR default called name
810 if we end up sending RFC1001 session initialize */
811 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -0400812 vol->cred_uid = current_uid();
813 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +1100814 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -0400815
816 /* default to only allowing write access to owner of the mount */
817 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
819 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -0700820 /* default is always to request posix paths. */
821 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -0400822 /* default to using server inode numbers where available */
823 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -0700824
Suresh Jayaraman6d20e842010-12-01 14:42:28 +0530825 vol->actimeo = CIFS_DEF_ACTIMEO;
826
Sean Finneyb9468452011-04-11 13:19:32 +0000827 if (!mountdata)
828 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Sean Finneyb9468452011-04-11 13:19:32 +0000830 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
831 if (!mountdata_copy)
832 goto cifs_parse_mount_err;
833
834 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400835 end = options + strlen(options);
Steve French50c2f752007-07-13 00:33:32 +0000836 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000837 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 separator[0] = options[4];
839 options += 5;
840 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000841 cFYI(1, "Null separator not allowed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
843 }
Steve French50c2f752007-07-13 00:33:32 +0000844
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 while ((data = strsep(&options, separator)) != NULL) {
846 if (!*data)
847 continue;
848 if ((value = strchr(data, '=')) != NULL)
849 *value++ = '\0';
850
Steve French50c2f752007-07-13 00:33:32 +0000851 /* Have to parse this before we parse for "user" */
852 if (strnicmp(data, "user_xattr", 10) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 vol->no_xattr = 0;
Steve French50c2f752007-07-13 00:33:32 +0000854 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 vol->no_xattr = 1;
856 } else if (strnicmp(data, "user", 4) == 0) {
Steve French4b952a92006-10-30 21:46:13 +0000857 if (!value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 printk(KERN_WARNING
859 "CIFS: invalid or missing username\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000860 goto cifs_parse_mount_err;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000861 } else if (!*value) {
Steve French4b952a92006-10-30 21:46:13 +0000862 /* null user, ie anonymous, authentication */
863 vol->nullauth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 }
Steve French8727c8a2011-02-25 01:11:56 -0600865 if (strnlen(value, MAX_USERNAME_SIZE) <
866 MAX_USERNAME_SIZE) {
Sean Finneyb9468452011-04-11 13:19:32 +0000867 vol->username = kstrdup(value, GFP_KERNEL);
868 if (!vol->username) {
869 printk(KERN_WARNING "CIFS: no memory "
870 "for username\n");
871 goto cifs_parse_mount_err;
872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 } else {
874 printk(KERN_WARNING "CIFS: username too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000875 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 }
877 } else if (strnicmp(data, "pass", 4) == 0) {
878 if (!value) {
879 vol->password = NULL;
880 continue;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000881 } else if (value[0] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 /* check if string begins with double comma
883 since that would mean the password really
884 does start with a comma, and would not
885 indicate an empty string */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000886 if (value[1] != separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 vol->password = NULL;
888 continue;
889 }
890 }
891 temp_len = strlen(value);
892 /* removed password length check, NTLM passwords
893 can be arbitrarily long */
894
Steve French50c2f752007-07-13 00:33:32 +0000895 /* if comma in password, the string will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 prematurely null terminated. Commas in password are
897 specified across the cifs mount interface by a double
898 comma ie ,, and a comma used as in other cases ie ','
899 as a parameter delimiter/separator is single and due
900 to the strsep above is temporarily zeroed. */
901
902 /* NB: password legally can have multiple commas and
903 the only illegal character in a password is null */
904
Steve French50c2f752007-07-13 00:33:32 +0000905 if ((value[temp_len] == 0) &&
Pavel Shilovsky4906e502011-04-14 22:00:56 +0400906 (value + temp_len < end) &&
Steve French09d1db52005-04-28 22:41:08 -0700907 (value[temp_len+1] == separator[0])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 /* reinsert comma */
909 value[temp_len] = separator[0];
Steve French50c2f752007-07-13 00:33:32 +0000910 temp_len += 2; /* move after second comma */
911 while (value[temp_len] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 if (value[temp_len] == separator[0]) {
Steve French50c2f752007-07-13 00:33:32 +0000913 if (value[temp_len+1] ==
Steve French09d1db52005-04-28 22:41:08 -0700914 separator[0]) {
915 /* skip second comma */
916 temp_len++;
Steve French50c2f752007-07-13 00:33:32 +0000917 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 /* single comma indicating start
919 of next parm */
920 break;
921 }
922 }
923 temp_len++;
924 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000925 if (value[temp_len] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 options = NULL;
927 } else {
928 value[temp_len] = 0;
929 /* point option to start of next parm */
930 options = value + temp_len + 1;
931 }
Steve French50c2f752007-07-13 00:33:32 +0000932 /* go from value to value + temp_len condensing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 double commas to singles. Note that this ends up
934 allocating a few bytes too many, which is ok */
Pekka Enberge915fc42005-09-06 15:18:35 -0700935 vol->password = kzalloc(temp_len, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000936 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000937 printk(KERN_WARNING "CIFS: no memory "
938 "for password\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000939 goto cifs_parse_mount_err;
Steve French433dc242005-04-28 22:41:08 -0700940 }
Steve French50c2f752007-07-13 00:33:32 +0000941 for (i = 0, j = 0; i < temp_len; i++, j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 vol->password[j] = value[i];
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000943 if (value[i] == separator[0]
Steve French09d1db52005-04-28 22:41:08 -0700944 && value[i+1] == separator[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /* skip second comma */
946 i++;
947 }
948 }
949 vol->password[j] = 0;
950 } else {
Pekka Enberge915fc42005-09-06 15:18:35 -0700951 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000952 if (vol->password == NULL) {
Steve French50c2f752007-07-13 00:33:32 +0000953 printk(KERN_WARNING "CIFS: no memory "
954 "for password\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000955 goto cifs_parse_mount_err;
Steve French433dc242005-04-28 22:41:08 -0700956 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 strcpy(vol->password, value);
958 }
Jeff Layton58f7f682009-06-10 09:57:55 -0400959 } else if (!strnicmp(data, "ip", 2) ||
960 !strnicmp(data, "addr", 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 if (!value || !*value) {
962 vol->UNCip = NULL;
Jeff Layton50b64e32009-06-02 06:55:20 -0400963 } else if (strnlen(value, INET6_ADDRSTRLEN) <
964 INET6_ADDRSTRLEN) {
Sean Finneyb9468452011-04-11 13:19:32 +0000965 vol->UNCip = kstrdup(value, GFP_KERNEL);
966 if (!vol->UNCip) {
967 printk(KERN_WARNING "CIFS: no memory "
968 "for UNC IP\n");
969 goto cifs_parse_mount_err;
970 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 } else {
Steve French50c2f752007-07-13 00:33:32 +0000972 printk(KERN_WARNING "CIFS: ip address "
973 "too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +0000974 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 }
Steve French50c2f752007-07-13 00:33:32 +0000976 } else if (strnicmp(data, "sec", 3) == 0) {
977 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000978 cERROR(1, "no security value specified");
Steve French50c2f752007-07-13 00:33:32 +0000979 continue;
980 } else if (strnicmp(value, "krb5i", 5) == 0) {
981 vol->secFlg |= CIFSSEC_MAY_KRB5 |
Steve French189acaa2006-06-23 02:33:48 +0000982 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800983 } else if (strnicmp(value, "krb5p", 5) == 0) {
Steve French50c2f752007-07-13 00:33:32 +0000984 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
985 CIFSSEC_MAY_KRB5; */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000986 cERROR(1, "Krb5 cifs privacy not supported");
Sean Finneyb9468452011-04-11 13:19:32 +0000987 goto cifs_parse_mount_err;
Steve Frenchbf820672005-12-01 22:32:42 -0800988 } else if (strnicmp(value, "krb5", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000989 vol->secFlg |= CIFSSEC_MAY_KRB5;
Steve Frenchac683922009-05-06 04:16:04 +0000990 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
991 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
992 CIFSSEC_MUST_SIGN;
993 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
994 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
Steve Frenchbf820672005-12-01 22:32:42 -0800995 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000996 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
Steve French189acaa2006-06-23 02:33:48 +0000997 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -0800998 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
Steve French750d1152006-06-27 06:28:30 +0000999 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve Frenchbf820672005-12-01 22:32:42 -08001000 } else if (strnicmp(value, "ntlmi", 5) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001001 vol->secFlg |= CIFSSEC_MAY_NTLM |
Steve French189acaa2006-06-23 02:33:48 +00001002 CIFSSEC_MUST_SIGN;
Steve Frenchbf820672005-12-01 22:32:42 -08001003 } else if (strnicmp(value, "ntlm", 4) == 0) {
1004 /* ntlm is default so can be turned off too */
Steve French750d1152006-06-27 06:28:30 +00001005 vol->secFlg |= CIFSSEC_MAY_NTLM;
Steve Frenchbf820672005-12-01 22:32:42 -08001006 } else if (strnicmp(value, "nontlm", 6) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001007 /* BB is there a better way to do this? */
Steve French750d1152006-06-27 06:28:30 +00001008 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
Steve French189acaa2006-06-23 02:33:48 +00001009#ifdef CONFIG_CIFS_WEAK_PW_HASH
1010 } else if (strnicmp(value, "lanman", 6) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001011 vol->secFlg |= CIFSSEC_MAY_LANMAN;
Steve French189acaa2006-06-23 02:33:48 +00001012#endif
Steve Frenchbf820672005-12-01 22:32:42 -08001013 } else if (strnicmp(value, "none", 4) == 0) {
Steve French189acaa2006-06-23 02:33:48 +00001014 vol->nullauth = 1;
Steve French50c2f752007-07-13 00:33:32 +00001015 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001016 cERROR(1, "bad security option: %s", value);
Sean Finneyb9468452011-04-11 13:19:32 +00001017 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001018 }
Steve French1cb06d02011-02-24 18:07:19 +00001019 } else if (strnicmp(data, "vers", 3) == 0) {
1020 if (!value || !*value) {
1021 cERROR(1, "no protocol version specified"
1022 " after vers= mount option");
1023 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1024 (strnicmp(value, "1", 1) == 0)) {
1025 /* this is the default */
1026 continue;
Steve French1cb06d02011-02-24 18:07:19 +00001027 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 } else if ((strnicmp(data, "unc", 3) == 0)
1029 || (strnicmp(data, "target", 6) == 0)
1030 || (strnicmp(data, "path", 4) == 0)) {
1031 if (!value || !*value) {
Steve French50c2f752007-07-13 00:33:32 +00001032 printk(KERN_WARNING "CIFS: invalid path to "
1033 "network resource\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001034 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 }
1036 if ((temp_len = strnlen(value, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001037 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001038 if (vol->UNC == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001039 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001040 strcpy(vol->UNC, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 if (strncmp(vol->UNC, "//", 2) == 0) {
1042 vol->UNC[0] = '\\';
1043 vol->UNC[1] = '\\';
Steve French50c2f752007-07-13 00:33:32 +00001044 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 printk(KERN_WARNING
Steve French50c2f752007-07-13 00:33:32 +00001046 "CIFS: UNC Path does not begin "
1047 "with // or \\\\ \n");
Sean Finneyb9468452011-04-11 13:19:32 +00001048 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 }
1050 } else {
1051 printk(KERN_WARNING "CIFS: UNC name too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001052 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 }
1054 } else if ((strnicmp(data, "domain", 3) == 0)
1055 || (strnicmp(data, "workgroup", 5) == 0)) {
1056 if (!value || !*value) {
1057 printk(KERN_WARNING "CIFS: invalid domain name\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001058 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
1060 /* BB are there cases in which a comma can be valid in
1061 a domain name and need special handling? */
Steve French39798772006-05-31 22:40:51 +00001062 if (strnlen(value, 256) < 256) {
Sean Finneyb9468452011-04-11 13:19:32 +00001063 vol->domainname = kstrdup(value, GFP_KERNEL);
1064 if (!vol->domainname) {
1065 printk(KERN_WARNING "CIFS: no memory "
1066 "for domainname\n");
1067 goto cifs_parse_mount_err;
1068 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00001069 cFYI(1, "Domain name set");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 } else {
Steve French50c2f752007-07-13 00:33:32 +00001071 printk(KERN_WARNING "CIFS: domain name too "
1072 "long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001073 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
Ben Greear3eb9a882010-09-01 17:06:02 -07001075 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1076 vol->srcaddr.ss_family = AF_UNSPEC;
1077
1078 if (!value || !*value) {
1079 printk(KERN_WARNING "CIFS: srcaddr value"
1080 " not specified.\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001081 goto cifs_parse_mount_err;
Ben Greear3eb9a882010-09-01 17:06:02 -07001082 }
1083 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1084 value, strlen(value));
Dan Carpenterb235f372010-10-25 07:02:56 +02001085 if (i == 0) {
Ben Greear3eb9a882010-09-01 17:06:02 -07001086 printk(KERN_WARNING "CIFS: Could not parse"
1087 " srcaddr: %s\n",
1088 value);
Sean Finneyb9468452011-04-11 13:19:32 +00001089 goto cifs_parse_mount_err;
Ben Greear3eb9a882010-09-01 17:06:02 -07001090 }
Steve French50c2f752007-07-13 00:33:32 +00001091 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1092 if (!value || !*value) {
1093 printk(KERN_WARNING
1094 "CIFS: invalid path prefix\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001095 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001096 }
1097 if ((temp_len = strnlen(value, 1024)) < 1024) {
Steve French4523cc32007-04-30 20:13:06 +00001098 if (value[0] != '/')
Steve French2fe87f02006-09-21 07:02:52 +00001099 temp_len++; /* missing leading slash */
Steve French50c2f752007-07-13 00:33:32 +00001100 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1101 if (vol->prepath == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001102 goto cifs_parse_mount_err;
Steve French4523cc32007-04-30 20:13:06 +00001103 if (value[0] != '/') {
Steve French2fe87f02006-09-21 07:02:52 +00001104 vol->prepath[0] = '/';
Steve French50c2f752007-07-13 00:33:32 +00001105 strcpy(vol->prepath+1, value);
Steve French2fe87f02006-09-21 07:02:52 +00001106 } else
Steve French50c2f752007-07-13 00:33:32 +00001107 strcpy(vol->prepath, value);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001108 cFYI(1, "prefix path %s", vol->prepath);
Steve French50c2f752007-07-13 00:33:32 +00001109 } else {
1110 printk(KERN_WARNING "CIFS: prefix too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001111 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001112 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 } else if (strnicmp(data, "iocharset", 9) == 0) {
1114 if (!value || !*value) {
Steve French63135e02007-07-17 17:34:02 +00001115 printk(KERN_WARNING "CIFS: invalid iocharset "
1116 "specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001117 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 }
1119 if (strnlen(value, 65) < 65) {
Sean Finneyb9468452011-04-11 13:19:32 +00001120 if (strnicmp(value, "default", 7)) {
1121 vol->iocharset = kstrdup(value,
1122 GFP_KERNEL);
1123
1124 if (!vol->iocharset) {
1125 printk(KERN_WARNING "CIFS: no "
1126 "memory for"
1127 "charset\n");
1128 goto cifs_parse_mount_err;
1129 }
1130 }
Steve French50c2f752007-07-13 00:33:32 +00001131 /* if iocharset not set then load_nls_default
1132 is used by caller */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001133 cFYI(1, "iocharset set to %s", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 } else {
Steve French63135e02007-07-17 17:34:02 +00001135 printk(KERN_WARNING "CIFS: iocharset name "
1136 "too long.\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001137 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 }
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001139 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1140 vol->linux_uid = simple_strtoul(value, &value, 0);
1141 uid_specified = true;
Jeff Laytonbd763312011-01-11 10:33:24 -05001142 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1143 vol->cred_uid = simple_strtoul(value, &value, 0);
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001144 } else if (!strnicmp(data, "forceuid", 8)) {
1145 override_uid = 1;
1146 } else if (!strnicmp(data, "noforceuid", 10)) {
1147 override_uid = 0;
1148 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1149 vol->linux_gid = simple_strtoul(value, &value, 0);
1150 gid_specified = true;
1151 } else if (!strnicmp(data, "forcegid", 8)) {
1152 override_gid = 1;
1153 } else if (!strnicmp(data, "noforcegid", 10)) {
1154 override_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 } else if (strnicmp(data, "file_mode", 4) == 0) {
1156 if (value && *value) {
1157 vol->file_mode =
1158 simple_strtoul(value, &value, 0);
1159 }
1160 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1161 if (value && *value) {
1162 vol->dir_mode =
1163 simple_strtoul(value, &value, 0);
1164 }
1165 } else if (strnicmp(data, "dirmode", 4) == 0) {
1166 if (value && *value) {
1167 vol->dir_mode =
1168 simple_strtoul(value, &value, 0);
1169 }
1170 } else if (strnicmp(data, "port", 4) == 0) {
1171 if (value && *value) {
1172 vol->port =
1173 simple_strtoul(value, &value, 0);
1174 }
1175 } else if (strnicmp(data, "rsize", 5) == 0) {
1176 if (value && *value) {
1177 vol->rsize =
1178 simple_strtoul(value, &value, 0);
1179 }
1180 } else if (strnicmp(data, "wsize", 5) == 0) {
1181 if (value && *value) {
1182 vol->wsize =
1183 simple_strtoul(value, &value, 0);
1184 }
1185 } else if (strnicmp(data, "sockopt", 5) == 0) {
Steve French6a5fa2362010-01-01 01:28:43 +00001186 if (!value || !*value) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001187 cERROR(1, "no socket option specified");
Steve French6a5fa2362010-01-01 01:28:43 +00001188 continue;
1189 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1190 vol->sockopt_tcp_nodelay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 }
1192 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1193 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001194 cFYI(1, "invalid (empty) netbiosname");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 } else {
Jeff Layton1397f2e2011-01-07 11:30:28 -05001196 memset(vol->source_rfc1001_name, 0x20,
1197 RFC1001_NAME_LEN);
1198 /*
1199 * FIXME: are there cases in which a comma can
1200 * be valid in workstation netbios name (and
1201 * need special handling)?
1202 */
1203 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1204 /* don't ucase netbiosname for user */
Steve French50c2f752007-07-13 00:33:32 +00001205 if (value[i] == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 break;
Jeff Layton1397f2e2011-01-07 11:30:28 -05001207 vol->source_rfc1001_name[i] = value[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 }
1209 /* The string has 16th byte zero still from
1210 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001211 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001212 printk(KERN_WARNING "CIFS: netbiosname"
1213 " longer than 15 truncated.\n");
Steve Frencha10faeb22005-08-22 21:38:31 -07001214 }
1215 } else if (strnicmp(data, "servern", 7) == 0) {
1216 /* servernetbiosname specified override *SMBSERVER */
1217 if (!value || !*value || (*value == ' ')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001218 cFYI(1, "empty server netbiosname specified");
Steve Frencha10faeb22005-08-22 21:38:31 -07001219 } else {
1220 /* last byte, type, is 0x20 for servr type */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001221 memset(vol->target_rfc1001_name, 0x20,
1222 RFC1001_NAME_LEN_WITH_NULL);
Steve Frencha10faeb22005-08-22 21:38:31 -07001223
Steve French50c2f752007-07-13 00:33:32 +00001224 for (i = 0; i < 15; i++) {
Steve Frencha10faeb22005-08-22 21:38:31 -07001225 /* BB are there cases in which a comma can be
Steve French50c2f752007-07-13 00:33:32 +00001226 valid in this workstation netbios name
1227 (and need special handling)? */
Steve Frencha10faeb22005-08-22 21:38:31 -07001228
Steve French50c2f752007-07-13 00:33:32 +00001229 /* user or mount helper must uppercase
1230 the netbiosname */
1231 if (value[i] == 0)
Steve Frencha10faeb22005-08-22 21:38:31 -07001232 break;
1233 else
Steve French50c2f752007-07-13 00:33:32 +00001234 vol->target_rfc1001_name[i] =
1235 value[i];
Steve Frencha10faeb22005-08-22 21:38:31 -07001236 }
1237 /* The string has 16th byte zero still from
1238 set at top of the function */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001239 if (i == RFC1001_NAME_LEN && value[i] != 0)
Steve French50c2f752007-07-13 00:33:32 +00001240 printk(KERN_WARNING "CIFS: server net"
1241 "biosname longer than 15 truncated.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 }
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301243 } else if (strnicmp(data, "actimeo", 7) == 0) {
1244 if (value && *value) {
1245 vol->actimeo = HZ * simple_strtoul(value,
1246 &value, 0);
1247 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1248 cERROR(1, "CIFS: attribute cache"
1249 "timeout too large");
Sean Finneyb9468452011-04-11 13:19:32 +00001250 goto cifs_parse_mount_err;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301251 }
1252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 } else if (strnicmp(data, "credentials", 4) == 0) {
1254 /* ignore */
1255 } else if (strnicmp(data, "version", 3) == 0) {
1256 /* ignore */
Steve French50c2f752007-07-13 00:33:32 +00001257 } else if (strnicmp(data, "guest", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 /* ignore */
Steve French71a394f2009-06-26 04:07:18 +00001259 } else if (strnicmp(data, "rw", 2) == 0) {
1260 /* ignore */
1261 } else if (strnicmp(data, "ro", 2) == 0) {
1262 /* ignore */
Steve Frenchedf1ae42008-10-29 00:47:57 +00001263 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1264 vol->noblocksnd = 1;
1265 } else if (strnicmp(data, "noautotune", 10) == 0) {
1266 vol->noautotune = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 } else if ((strnicmp(data, "suid", 4) == 0) ||
1268 (strnicmp(data, "nosuid", 6) == 0) ||
1269 (strnicmp(data, "exec", 4) == 0) ||
1270 (strnicmp(data, "noexec", 6) == 0) ||
1271 (strnicmp(data, "nodev", 5) == 0) ||
1272 (strnicmp(data, "noauto", 6) == 0) ||
1273 (strnicmp(data, "dev", 3) == 0)) {
1274 /* The mount tool or mount.cifs helper (if present)
Steve French50c2f752007-07-13 00:33:32 +00001275 uses these opts to set flags, and the flags are read
1276 by the kernel vfs layer before we get here (ie
1277 before read super) so there is no point trying to
1278 parse these options again and set anything and it
1279 is ok to just ignore them */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 } else if (strnicmp(data, "hard", 4) == 0) {
1282 vol->retry = 1;
1283 } else if (strnicmp(data, "soft", 4) == 0) {
1284 vol->retry = 0;
1285 } else if (strnicmp(data, "perm", 4) == 0) {
1286 vol->noperm = 0;
1287 } else if (strnicmp(data, "noperm", 6) == 0) {
1288 vol->noperm = 1;
Steve French6a0b4822005-04-28 22:41:05 -07001289 } else if (strnicmp(data, "mapchars", 8) == 0) {
1290 vol->remap = 1;
1291 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1292 vol->remap = 0;
Steve French50c2f752007-07-13 00:33:32 +00001293 } else if (strnicmp(data, "sfu", 3) == 0) {
1294 vol->sfu_emul = 1;
1295 } else if (strnicmp(data, "nosfu", 5) == 0) {
1296 vol->sfu_emul = 0;
Steve French2c1b8612008-10-16 18:35:21 +00001297 } else if (strnicmp(data, "nodfs", 5) == 0) {
1298 vol->nodfs = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001299 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1300 vol->posix_paths = 1;
1301 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1302 vol->posix_paths = 0;
Steve Frenchc18c8422007-07-18 23:21:09 +00001303 } else if (strnicmp(data, "nounix", 6) == 0) {
1304 vol->no_linux_ext = 1;
1305 } else if (strnicmp(data, "nolinux", 7) == 0) {
1306 vol->no_linux_ext = 1;
Steve French50c2f752007-07-13 00:33:32 +00001307 } else if ((strnicmp(data, "nocase", 6) == 0) ||
Steve Frencha10faeb22005-08-22 21:38:31 -07001308 (strnicmp(data, "ignorecase", 10) == 0)) {
Steve French50c2f752007-07-13 00:33:32 +00001309 vol->nocase = 1;
Jeff Laytonf636a342010-07-26 10:29:58 -04001310 } else if (strnicmp(data, "mand", 4) == 0) {
1311 /* ignore */
1312 } else if (strnicmp(data, "nomand", 6) == 0) {
1313 /* ignore */
1314 } else if (strnicmp(data, "_netdev", 7) == 0) {
1315 /* ignore */
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001316 } else if (strnicmp(data, "brl", 3) == 0) {
1317 vol->nobrl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001318 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
Steve French1c955182005-08-30 20:58:07 -07001319 (strnicmp(data, "nolock", 6) == 0)) {
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001320 vol->nobrl = 1;
Steve Frenchd3485d32005-08-19 11:04:29 -07001321 /* turn off mandatory locking in mode
1322 if remote locking is turned off since the
1323 local vfs will do advisory */
Steve French50c2f752007-07-13 00:33:32 +00001324 if (vol->file_mode ==
1325 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001326 vol->file_mode = S_IALLUGO;
Steve French13a6e422008-12-02 17:24:33 +00001327 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1328 /* will take the shorter form "forcemand" as well */
1329 /* This mount option will force use of mandatory
1330 (DOS/Windows style) byte range locks, instead of
1331 using posix advisory byte range locks, even if the
1332 Unix extensions are available and posix locks would
1333 be supported otherwise. If Unix extensions are not
1334 negotiated this has no effect since mandatory locks
1335 would be used (mandatory locks is all that those
1336 those servers support) */
1337 vol->mand_lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 } else if (strnicmp(data, "setuids", 7) == 0) {
1339 vol->setuids = 1;
1340 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1341 vol->setuids = 0;
Jeff Laytond0a9c072008-05-12 22:23:49 +00001342 } else if (strnicmp(data, "dynperm", 7) == 0) {
1343 vol->dynperm = true;
1344 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1345 vol->dynperm = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 } else if (strnicmp(data, "nohard", 6) == 0) {
1347 vol->retry = 0;
1348 } else if (strnicmp(data, "nosoft", 6) == 0) {
1349 vol->retry = 1;
1350 } else if (strnicmp(data, "nointr", 6) == 0) {
1351 vol->intr = 0;
1352 } else if (strnicmp(data, "intr", 4) == 0) {
1353 vol->intr = 1;
Steve Frenchbe652442009-02-23 15:21:59 +00001354 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1355 vol->nostrictsync = 1;
1356 } else if (strnicmp(data, "strictsync", 10) == 0) {
1357 vol->nostrictsync = 0;
Steve French50c2f752007-07-13 00:33:32 +00001358 } else if (strnicmp(data, "serverino", 7) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 vol->server_ino = 1;
Steve French50c2f752007-07-13 00:33:32 +00001360 } else if (strnicmp(data, "noserverino", 9) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 vol->server_ino = 0;
Steve French50c2f752007-07-13 00:33:32 +00001362 } else if (strnicmp(data, "cifsacl", 7) == 0) {
Steve French0a4b92c2006-01-12 15:44:21 -08001363 vol->cifs_acl = 1;
1364 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1365 vol->cifs_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001366 } else if (strnicmp(data, "acl", 3) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 vol->no_psx_acl = 0;
Steve French50c2f752007-07-13 00:33:32 +00001368 } else if (strnicmp(data, "noacl", 5) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 vol->no_psx_acl = 1;
Steve French84210e92008-10-23 04:42:37 +00001370 } else if (strnicmp(data, "locallease", 6) == 0) {
1371 vol->local_lease = 1;
Steve French50c2f752007-07-13 00:33:32 +00001372 } else if (strnicmp(data, "sign", 4) == 0) {
Steve French750d1152006-06-27 06:28:30 +00001373 vol->secFlg |= CIFSSEC_MUST_SIGN;
Steve French95b1cb92008-05-15 16:44:38 +00001374 } else if (strnicmp(data, "seal", 4) == 0) {
1375 /* we do not do the following in secFlags because seal
1376 is a per tree connection (mount) not a per socket
1377 or per-smb connection option in the protocol */
1378 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1379 vol->seal = 1;
Steve French50c2f752007-07-13 00:33:32 +00001380 } else if (strnicmp(data, "direct", 6) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 vol->direct_io = 1;
Steve French50c2f752007-07-13 00:33:32 +00001382 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 vol->direct_io = 1;
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05001384 } else if (strnicmp(data, "strictcache", 11) == 0) {
1385 vol->strict_io = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 } else if (strnicmp(data, "noac", 4) == 0) {
Steve French50c2f752007-07-13 00:33:32 +00001387 printk(KERN_WARNING "CIFS: Mount option noac not "
1388 "supported. Instead set "
1389 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301390 } else if (strnicmp(data, "fsc", 3) == 0) {
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301391#ifndef CONFIG_CIFS_FSCACHE
1392 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1393 "kernel config option set");
Sean Finneyb9468452011-04-11 13:19:32 +00001394 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301395#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301396 vol->fsc = true;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001397 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1398 vol->mfsymlinks = true;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001399 } else if (strnicmp(data, "multiuser", 8) == 0) {
1400 vol->multiuser = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 } else
Steve French50c2f752007-07-13 00:33:32 +00001402 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1403 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 }
1405 if (vol->UNC == NULL) {
Steve French4523cc32007-04-30 20:13:06 +00001406 if (devname == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00001407 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1408 "target\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001409 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 }
1411 if ((temp_len = strnlen(devname, 300)) < 300) {
Steve French50c2f752007-07-13 00:33:32 +00001412 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
Steve French4523cc32007-04-30 20:13:06 +00001413 if (vol->UNC == NULL)
Sean Finneyb9468452011-04-11 13:19:32 +00001414 goto cifs_parse_mount_err;
Steve French50c2f752007-07-13 00:33:32 +00001415 strcpy(vol->UNC, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 if (strncmp(vol->UNC, "//", 2) == 0) {
1417 vol->UNC[0] = '\\';
1418 vol->UNC[1] = '\\';
1419 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
Steve French50c2f752007-07-13 00:33:32 +00001420 printk(KERN_WARNING "CIFS: UNC Path does not "
1421 "begin with // or \\\\ \n");
Sean Finneyb9468452011-04-11 13:19:32 +00001422 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 }
Igor Mammedov7c5e6282008-05-08 20:48:42 +00001424 value = strpbrk(vol->UNC+2, "/\\");
1425 if (value)
1426 *value = '\\';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 } else {
1428 printk(KERN_WARNING "CIFS: UNC name too long\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001429 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 }
1431 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001432
1433 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1434 cERROR(1, "Multiuser mounts currently require krb5 "
1435 "authentication!");
Sean Finneyb9468452011-04-11 13:19:32 +00001436 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001437 }
1438
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001439 if (vol->UNCip == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 vol->UNCip = &vol->UNC[2];
1441
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001442 if (uid_specified)
1443 vol->override_uid = override_uid;
1444 else if (override_uid == 1)
1445 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1446 "specified with no uid= option.\n");
1447
1448 if (gid_specified)
1449 vol->override_gid = override_gid;
1450 else if (override_gid == 1)
1451 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1452 "specified with no gid= option.\n");
1453
Sean Finneyb9468452011-04-11 13:19:32 +00001454 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001456
1457cifs_parse_mount_err:
1458 kfree(mountdata_copy);
1459 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460}
1461
Ben Greear3eb9a882010-09-01 17:06:02 -07001462/** Returns true if srcaddr isn't specified and rhs isn't
1463 * specified, or if srcaddr is specified and
1464 * matches the IP address of the rhs argument.
1465 */
Jeff Layton45151482010-07-06 20:43:02 -04001466static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001467srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1468{
1469 switch (srcaddr->sa_family) {
1470 case AF_UNSPEC:
1471 return (rhs->sa_family == AF_UNSPEC);
1472 case AF_INET: {
1473 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1474 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1475 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1476 }
1477 case AF_INET6: {
1478 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1479 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1480 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1481 }
1482 default:
1483 WARN_ON(1);
1484 return false; /* don't expect to be here */
1485 }
1486}
1487
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001488/*
1489 * If no port is specified in addr structure, we try to match with 445 port
1490 * and if it fails - with 139 ports. It should be called only if address
1491 * families of server and addr are equal.
1492 */
1493static bool
1494match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1495{
Steve French6da97912011-03-13 18:55:55 +00001496 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001497
1498 switch (addr->sa_family) {
1499 case AF_INET:
1500 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1501 port = ((struct sockaddr_in *) addr)->sin_port;
1502 break;
1503 case AF_INET6:
1504 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1505 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1506 break;
1507 default:
1508 WARN_ON(1);
1509 return false;
1510 }
1511
1512 if (!port) {
1513 port = htons(CIFS_PORT);
1514 if (port == *sport)
1515 return true;
1516
1517 port = htons(RFC1001_PORT);
1518 }
1519
1520 return port == *sport;
1521}
Ben Greear3eb9a882010-09-01 17:06:02 -07001522
1523static bool
1524match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1525 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526{
Jeff Layton45151482010-07-06 20:43:02 -04001527 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001528 case AF_INET: {
1529 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1530 struct sockaddr_in *srv_addr4 =
1531 (struct sockaddr_in *)&server->dstaddr;
1532
1533 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001534 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001535 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001536 }
1537 case AF_INET6: {
1538 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1539 struct sockaddr_in6 *srv_addr6 =
1540 (struct sockaddr_in6 *)&server->dstaddr;
1541
Jeff Layton45151482010-07-06 20:43:02 -04001542 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001543 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001544 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001545 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001546 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001547 break;
1548 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001549 default:
1550 WARN_ON(1);
1551 return false; /* don't expect to be here */
1552 }
Jeff Layton45151482010-07-06 20:43:02 -04001553
Ben Greear3eb9a882010-09-01 17:06:02 -07001554 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1555 return false;
1556
Jeff Layton45151482010-07-06 20:43:02 -04001557 return true;
1558}
1559
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001560static bool
1561match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1562{
1563 unsigned int secFlags;
1564
1565 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1566 secFlags = vol->secFlg;
1567 else
1568 secFlags = global_secflags | vol->secFlg;
1569
1570 switch (server->secType) {
1571 case LANMAN:
1572 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1573 return false;
1574 break;
1575 case NTLMv2:
1576 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1577 return false;
1578 break;
1579 case NTLM:
1580 if (!(secFlags & CIFSSEC_MAY_NTLM))
1581 return false;
1582 break;
1583 case Kerberos:
1584 if (!(secFlags & CIFSSEC_MAY_KRB5))
1585 return false;
1586 break;
1587 case RawNTLMSSP:
1588 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1589 return false;
1590 break;
1591 default:
1592 /* shouldn't happen */
1593 return false;
1594 }
1595
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001596 /* now check if signing mode is acceptable */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001597 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1598 (server->secMode & SECMODE_SIGN_REQUIRED))
1599 return false;
1600 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1601 (server->secMode &
1602 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1603 return false;
1604
1605 return true;
1606}
1607
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001608static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1609 struct smb_vol *vol)
1610{
1611 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1612 return 0;
1613
1614 if (!match_address(server, addr,
1615 (struct sockaddr *)&vol->srcaddr))
1616 return 0;
1617
1618 if (!match_port(server, addr))
1619 return 0;
1620
1621 if (!match_security(server, vol))
1622 return 0;
1623
1624 return 1;
1625}
1626
Jeff Layton45151482010-07-06 20:43:02 -04001627static struct TCP_Server_Info *
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001628cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04001629{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001630 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301632 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04001633 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001634 if (!match_server(server, addr, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001635 continue;
1636
Jeff Laytone7ddee92008-11-14 13:44:38 -05001637 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301638 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001639 cFYI(1, "Existing tcp session with server found");
Jeff Laytone7ddee92008-11-14 13:44:38 -05001640 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301642 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 return NULL;
1644}
1645
Jeff Layton14fbf502008-11-14 13:53:46 -05001646static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05001647cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
Jeff Laytone7ddee92008-11-14 13:44:38 -05001649 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301651 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001652 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301653 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001654 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 }
Steve Frenchdea570e02008-05-06 22:05:51 +00001656
Rob Landleyf1d0c992011-01-22 15:44:05 -06001657 put_net(cifs_net_ns(server));
1658
Jeff Laytone7ddee92008-11-14 13:44:38 -05001659 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301660 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05001661
Jeff Laytonc74093b2011-01-11 07:24:23 -05001662 cancel_delayed_work_sync(&server->echo);
1663
Jeff Laytone7ddee92008-11-14 13:44:38 -05001664 spin_lock(&GlobalMid_Lock);
1665 server->tcpStatus = CifsExiting;
1666 spin_unlock(&GlobalMid_Lock);
1667
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001668 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301669 cifs_fscache_release_client_cookie(server);
1670
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05001671 kfree(server->session_key.response);
1672 server->session_key.response = NULL;
1673 server->session_key.len = 0;
1674
Jeff Laytone7ddee92008-11-14 13:44:38 -05001675 task = xchg(&server->tsk, NULL);
1676 if (task)
1677 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678}
1679
Jeff Layton63c038c2008-12-01 18:41:46 -05001680static struct TCP_Server_Info *
1681cifs_get_tcp_session(struct smb_vol *volume_info)
1682{
1683 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001684 struct sockaddr_storage addr;
Jeff Layton63c038c2008-12-01 18:41:46 -05001685 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1686 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1687 int rc;
1688
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001689 memset(&addr, 0, sizeof(struct sockaddr_storage));
Jeff Layton63c038c2008-12-01 18:41:46 -05001690
Joe Perchesb6b38f72010-04-21 03:50:45 +00001691 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001692
Jeff Layton63c038c2008-12-01 18:41:46 -05001693 if (volume_info->UNCip && volume_info->UNC) {
Jeff Layton50d97162010-07-06 20:43:01 -04001694 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1695 volume_info->UNCip,
David Howells67b76262010-07-22 18:33:01 +01001696 strlen(volume_info->UNCip),
Jeff Layton50d97162010-07-06 20:43:01 -04001697 volume_info->port);
Jeff Layton1e68b2b2009-06-11 10:27:30 -04001698 if (!rc) {
Jeff Layton63c038c2008-12-01 18:41:46 -05001699 /* we failed translating address */
1700 rc = -EINVAL;
1701 goto out_err;
1702 }
Jeff Layton63c038c2008-12-01 18:41:46 -05001703 } else if (volume_info->UNCip) {
1704 /* BB using ip addr as tcp_ses name to connect to the
1705 DFS root below */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001706 cERROR(1, "Connecting to DFS root not implemented yet");
Jeff Layton63c038c2008-12-01 18:41:46 -05001707 rc = -EINVAL;
1708 goto out_err;
1709 } else /* which tcp_sess DFS root would we conect to */ {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001710 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1711 "unc=//192.168.1.100/public) specified");
Jeff Layton63c038c2008-12-01 18:41:46 -05001712 rc = -EINVAL;
1713 goto out_err;
1714 }
1715
1716 /* see if we already have a matching tcp_ses */
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001717 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05001718 if (tcp_ses)
1719 return tcp_ses;
1720
1721 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1722 if (!tcp_ses) {
1723 rc = -ENOMEM;
1724 goto out_err;
1725 }
1726
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001727 rc = cifs_crypto_shash_allocate(tcp_ses);
1728 if (rc) {
1729 cERROR(1, "could not setup hash structures rc %d", rc);
1730 goto out_err;
1731 }
1732
Rob Landleyf1d0c992011-01-22 15:44:05 -06001733 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05001734 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1735 if (IS_ERR(tcp_ses->hostname)) {
1736 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001737 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001738 }
1739
1740 tcp_ses->noblocksnd = volume_info->noblocksnd;
1741 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00001742 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Jeff Layton63c038c2008-12-01 18:41:46 -05001743 atomic_set(&tcp_ses->inFlight, 0);
1744 init_waitqueue_head(&tcp_ses->response_q);
1745 init_waitqueue_head(&tcp_ses->request_q);
1746 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1747 mutex_init(&tcp_ses->srv_mutex);
1748 memcpy(tcp_ses->workstation_RFC1001_name,
1749 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1750 memcpy(tcp_ses->server_RFC1001_name,
1751 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05001752 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05001753 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00001754 tcp_ses->lstrp = jiffies;
Jeff Layton63c038c2008-12-01 18:41:46 -05001755 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1756 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05001757 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton63c038c2008-12-01 18:41:46 -05001758
1759 /*
1760 * at this point we are the only ones with the pointer
1761 * to the struct since the kernel thread not created yet
1762 * no need to spinlock this init of tcpStatus or srv_count
1763 */
1764 tcp_ses->tcpStatus = CifsNew;
Ben Greear3eb9a882010-09-01 17:06:02 -07001765 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1766 sizeof(tcp_ses->srcaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05001767 ++tcp_ses->srv_count;
1768
Jeff Laytona9ac49d2009-01-22 14:43:21 -05001769 if (addr.ss_family == AF_INET6) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001770 cFYI(1, "attempting ipv6 connect");
Jeff Layton63c038c2008-12-01 18:41:46 -05001771 /* BB should we allow ipv6 on port 139? */
1772 /* other OS never observed in Wild doing 139 with v6 */
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001773 memcpy(&tcp_ses->dstaddr, sin_server6,
1774 sizeof(struct sockaddr_in6));
1775 } else
1776 memcpy(&tcp_ses->dstaddr, sin_server,
1777 sizeof(struct sockaddr_in));
1778
1779 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05001780 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001781 cERROR(1, "Error connecting to socket. Aborting operation");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001782 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001783 }
1784
1785 /*
1786 * since we're in a cifs function already, we know that
1787 * this will succeed. No need for try_module_get().
1788 */
1789 __module_get(THIS_MODULE);
1790 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1791 tcp_ses, "cifsd");
1792 if (IS_ERR(tcp_ses->tsk)) {
1793 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001794 cERROR(1, "error %d create cifsd thread", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05001795 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001796 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05001797 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00001798 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05001799
1800 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301801 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001802 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301803 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05001804
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05301805 cifs_fscache_get_client_cookie(tcp_ses);
1806
Jeff Laytonc74093b2011-01-11 07:24:23 -05001807 /* queue echo request delayed work */
1808 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1809
Jeff Layton63c038c2008-12-01 18:41:46 -05001810 return tcp_ses;
1811
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05001812out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05001813 cifs_crypto_shash_release(tcp_ses);
1814
Rob Landleyf1d0c992011-01-22 15:44:05 -06001815 put_net(cifs_net_ns(tcp_ses));
1816
Jeff Layton63c038c2008-12-01 18:41:46 -05001817out_err:
1818 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00001819 if (!IS_ERR(tcp_ses->hostname))
1820 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05001821 if (tcp_ses->ssocket)
1822 sock_release(tcp_ses->ssocket);
1823 kfree(tcp_ses);
1824 }
1825 return ERR_PTR(rc);
1826}
1827
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001828static int match_session(struct cifsSesInfo *ses, struct smb_vol *vol)
1829{
1830 switch (ses->server->secType) {
1831 case Kerberos:
1832 if (vol->cred_uid != ses->cred_uid)
1833 return 0;
1834 break;
1835 default:
1836 /* anything else takes username/password */
1837 if (ses->user_name == NULL)
1838 return 0;
1839 if (strncmp(ses->user_name, vol->username,
1840 MAX_USERNAME_SIZE))
1841 return 0;
1842 if (strlen(vol->username) != 0 &&
1843 ses->password != NULL &&
1844 strncmp(ses->password,
1845 vol->password ? vol->password : "",
1846 MAX_PASSWORD_SIZE))
1847 return 0;
1848 }
1849 return 1;
1850}
1851
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852static struct cifsSesInfo *
Jeff Layton4ff67b72010-07-06 20:43:02 -04001853cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 struct cifsSesInfo *ses;
1856
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301857 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04001858 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00001859 if (!match_session(ses, vol))
1860 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05001861 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301862 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001863 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301865 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 return NULL;
1867}
1868
Jeff Layton14fbf502008-11-14 13:53:46 -05001869static void
1870cifs_put_smb_ses(struct cifsSesInfo *ses)
1871{
1872 int xid;
1873 struct TCP_Server_Info *server = ses->server;
1874
Jeff Layton36988c72010-04-24 07:57:43 -04001875 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301876 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001877 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301878 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001879 return;
1880 }
1881
1882 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301883 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05001884
1885 if (ses->status == CifsGood) {
1886 xid = GetXid();
1887 CIFSSMBLogoff(xid, ses);
1888 _FreeXid(xid);
1889 }
1890 sesInfoFree(ses);
1891 cifs_put_tcp_session(server);
1892}
1893
Steve Frenchd9b94202011-04-12 01:24:57 +00001894static bool warned_on_ntlm; /* globals init to false automatically */
1895
Jeff Layton36988c72010-04-24 07:57:43 -04001896static struct cifsSesInfo *
1897cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1898{
1899 int rc = -ENOMEM, xid;
1900 struct cifsSesInfo *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001901 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1902 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04001903
1904 xid = GetXid();
1905
Jeff Layton4ff67b72010-07-06 20:43:02 -04001906 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04001907 if (ses) {
1908 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1909
Jeff Layton36988c72010-04-24 07:57:43 -04001910 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001911 rc = cifs_negotiate_protocol(xid, ses);
1912 if (rc) {
1913 mutex_unlock(&ses->session_mutex);
1914 /* problem -- put our ses reference */
1915 cifs_put_smb_ses(ses);
1916 FreeXid(xid);
1917 return ERR_PTR(rc);
1918 }
Jeff Layton36988c72010-04-24 07:57:43 -04001919 if (ses->need_reconnect) {
1920 cFYI(1, "Session needs reconnect");
1921 rc = cifs_setup_session(xid, ses,
1922 volume_info->local_nls);
1923 if (rc) {
1924 mutex_unlock(&ses->session_mutex);
1925 /* problem -- put our reference */
1926 cifs_put_smb_ses(ses);
1927 FreeXid(xid);
1928 return ERR_PTR(rc);
1929 }
1930 }
1931 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04001932
1933 /* existing SMB ses has a server reference already */
1934 cifs_put_tcp_session(server);
Jeff Layton36988c72010-04-24 07:57:43 -04001935 FreeXid(xid);
1936 return ses;
1937 }
1938
1939 cFYI(1, "Existing smb sess not found");
1940 ses = sesInfoAlloc();
1941 if (ses == NULL)
1942 goto get_ses_fail;
1943
1944 /* new SMB session uses our server ref */
1945 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001946 if (server->dstaddr.ss_family == AF_INET6)
1947 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04001948 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001949 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04001950
Steve French8727c8a2011-02-25 01:11:56 -06001951 if (volume_info->username) {
1952 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1953 if (!ses->user_name)
1954 goto get_ses_fail;
1955 }
Jeff Layton36988c72010-04-24 07:57:43 -04001956
1957 /* volume_info->password freed at unmount */
1958 if (volume_info->password) {
1959 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1960 if (!ses->password)
1961 goto get_ses_fail;
1962 }
1963 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05001964 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1965 if (!ses->domainName)
1966 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04001967 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001968 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04001969 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00001970
1971 /* ntlmv2 is much stronger than ntlm security, and has been broadly
1972 supported for many years, time to update default security mechanism */
1973 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1974 warned_on_ntlm = true;
1975 cERROR(1, "default security mechanism requested. The default "
1976 "security mechanism will be upgraded from ntlm to "
1977 "ntlmv2 in kernel release 2.6.41");
1978 }
Jeff Layton36988c72010-04-24 07:57:43 -04001979 ses->overrideSecFlg = volume_info->secFlg;
1980
1981 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04001982 rc = cifs_negotiate_protocol(xid, ses);
1983 if (!rc)
1984 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04001985 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00001986 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04001987 goto get_ses_fail;
1988
1989 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301990 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04001991 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301992 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04001993
1994 FreeXid(xid);
1995 return ses;
1996
1997get_ses_fail:
1998 sesInfoFree(ses);
1999 FreeXid(xid);
2000 return ERR_PTR(rc);
2001}
2002
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002003static int match_tcon(struct cifsTconInfo *tcon, const char *unc)
2004{
2005 if (tcon->tidStatus == CifsExiting)
2006 return 0;
2007 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2008 return 0;
2009 return 1;
2010}
2011
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012static struct cifsTconInfo *
Jeff Laytonf1987b42008-11-15 11:12:47 -05002013cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014{
2015 struct list_head *tmp;
2016 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302018 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002019 list_for_each(tmp, &ses->tcon_list) {
2020 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002021 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002022 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002023 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302024 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 return tcon;
2026 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302027 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 return NULL;
2029}
2030
Jeff Laytonf1987b42008-11-15 11:12:47 -05002031static void
2032cifs_put_tcon(struct cifsTconInfo *tcon)
2033{
2034 int xid;
2035 struct cifsSesInfo *ses = tcon->ses;
2036
Jeff Laytond00c28d2010-04-24 07:57:44 -04002037 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302038 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002039 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302040 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002041 return;
2042 }
2043
2044 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302045 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002046
2047 xid = GetXid();
2048 CIFSSMBTDis(xid, tcon);
2049 _FreeXid(xid);
2050
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302051 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002052 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002053 cifs_put_smb_ses(ses);
2054}
2055
Jeff Laytond00c28d2010-04-24 07:57:44 -04002056static struct cifsTconInfo *
2057cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2058{
2059 int rc, xid;
2060 struct cifsTconInfo *tcon;
2061
2062 tcon = cifs_find_tcon(ses, volume_info->UNC);
2063 if (tcon) {
2064 cFYI(1, "Found match on UNC path");
2065 /* existing tcon already has a reference */
2066 cifs_put_smb_ses(ses);
2067 if (tcon->seal != volume_info->seal)
2068 cERROR(1, "transport encryption setting "
2069 "conflicts with existing tid");
2070 return tcon;
2071 }
2072
2073 tcon = tconInfoAlloc();
2074 if (tcon == NULL) {
2075 rc = -ENOMEM;
2076 goto out_fail;
2077 }
2078
2079 tcon->ses = ses;
2080 if (volume_info->password) {
2081 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2082 if (!tcon->password) {
2083 rc = -ENOMEM;
2084 goto out_fail;
2085 }
2086 }
2087
2088 if (strchr(volume_info->UNC + 3, '\\') == NULL
2089 && strchr(volume_info->UNC + 3, '/') == NULL) {
2090 cERROR(1, "Missing share name");
2091 rc = -ENODEV;
2092 goto out_fail;
2093 }
2094
2095 /* BB Do we need to wrap session_mutex around
2096 * this TCon call and Unix SetFS as
2097 * we do on SessSetup and reconnect? */
2098 xid = GetXid();
2099 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2100 FreeXid(xid);
2101 cFYI(1, "CIFS Tcon rc = %d", rc);
2102 if (rc)
2103 goto out_fail;
2104
2105 if (volume_info->nodfs) {
2106 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2107 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2108 }
2109 tcon->seal = volume_info->seal;
2110 /* we can have only one retry value for a connection
2111 to a share so for resources mounted more than once
2112 to the same server share the last value passed in
2113 for the retry flag is used */
2114 tcon->retry = volume_info->retry;
2115 tcon->nocase = volume_info->nocase;
2116 tcon->local_lease = volume_info->local_lease;
2117
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302118 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002119 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302120 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002121
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302122 cifs_fscache_get_super_cookie(tcon);
2123
Jeff Laytond00c28d2010-04-24 07:57:44 -04002124 return tcon;
2125
2126out_fail:
2127 tconInfoFree(tcon);
2128 return ERR_PTR(rc);
2129}
2130
Jeff Layton9d002df2010-10-06 19:51:11 -04002131void
2132cifs_put_tlink(struct tcon_link *tlink)
2133{
2134 if (!tlink || IS_ERR(tlink))
2135 return;
2136
2137 if (!atomic_dec_and_test(&tlink->tl_count) ||
2138 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2139 tlink->tl_time = jiffies;
2140 return;
2141 }
2142
2143 if (!IS_ERR(tlink_tcon(tlink)))
2144 cifs_put_tcon(tlink_tcon(tlink));
2145 kfree(tlink);
2146 return;
2147}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002148
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002149static inline struct tcon_link *
2150cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb);
2151
2152static int
2153compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2154{
2155 struct cifs_sb_info *old = CIFS_SB(sb);
2156 struct cifs_sb_info *new = mnt_data->cifs_sb;
2157
2158 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2159 return 0;
2160
2161 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2162 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2163 return 0;
2164
2165 if (old->rsize != new->rsize)
2166 return 0;
2167
2168 /*
2169 * We want to share sb only if we don't specify wsize or specified wsize
2170 * is greater or equal than existing one.
2171 */
2172 if (new->wsize && new->wsize < old->wsize)
2173 return 0;
2174
2175 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2176 return 0;
2177
2178 if (old->mnt_file_mode != new->mnt_file_mode ||
2179 old->mnt_dir_mode != new->mnt_dir_mode)
2180 return 0;
2181
2182 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2183 return 0;
2184
2185 if (old->actimeo != new->actimeo)
2186 return 0;
2187
2188 return 1;
2189}
2190
2191int
2192cifs_match_super(struct super_block *sb, void *data)
2193{
2194 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2195 struct smb_vol *volume_info;
2196 struct cifs_sb_info *cifs_sb;
2197 struct TCP_Server_Info *tcp_srv;
2198 struct cifsSesInfo *ses;
2199 struct cifsTconInfo *tcon;
2200 struct tcon_link *tlink;
2201 struct sockaddr_storage addr;
2202 int rc = 0;
2203
2204 memset(&addr, 0, sizeof(struct sockaddr_storage));
2205
2206 spin_lock(&cifs_tcp_ses_lock);
2207 cifs_sb = CIFS_SB(sb);
2208 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2209 if (IS_ERR(tlink)) {
2210 spin_unlock(&cifs_tcp_ses_lock);
2211 return rc;
2212 }
2213 tcon = tlink_tcon(tlink);
2214 ses = tcon->ses;
2215 tcp_srv = ses->server;
2216
2217 volume_info = mnt_data->vol;
2218
2219 if (!volume_info->UNCip || !volume_info->UNC)
2220 goto out;
2221
2222 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2223 volume_info->UNCip,
2224 strlen(volume_info->UNCip),
2225 volume_info->port);
2226 if (!rc)
2227 goto out;
2228
2229 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2230 !match_session(ses, volume_info) ||
2231 !match_tcon(tcon, volume_info->UNC)) {
2232 rc = 0;
2233 goto out;
2234 }
2235
2236 rc = compare_mount_options(sb, mnt_data);
2237out:
2238 cifs_put_tlink(tlink);
2239 spin_unlock(&cifs_tcp_ses_lock);
2240 return rc;
2241}
2242
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243int
Steve French50c2f752007-07-13 00:33:32 +00002244get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2245 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
Steve French366781c2008-01-25 10:12:41 +00002246 struct dfs_info3_param **preferrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247{
2248 char *temp_unc;
2249 int rc = 0;
2250
2251 *pnum_referrals = 0;
Steve French366781c2008-01-25 10:12:41 +00002252 *preferrals = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253
2254 if (pSesInfo->ipc_tid == 0) {
2255 temp_unc = kmalloc(2 /* for slashes */ +
Steve French50c2f752007-07-13 00:33:32 +00002256 strnlen(pSesInfo->serverName,
2257 SERVER_NAME_LEN_WITH_NULL * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 + 1 + 4 /* slash IPC$ */ + 2,
2259 GFP_KERNEL);
2260 if (temp_unc == NULL)
2261 return -ENOMEM;
2262 temp_unc[0] = '\\';
2263 temp_unc[1] = '\\';
2264 strcpy(temp_unc + 2, pSesInfo->serverName);
2265 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2266 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002267 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 kfree(temp_unc);
2269 }
2270 if (rc == 0)
Steve Frenchc2cf07d2008-05-15 06:20:02 +00002271 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
Steve French737b7582005-04-28 22:41:06 -07002272 pnum_referrals, nls_codepage, remap);
Steve French366781c2008-01-25 10:12:41 +00002273 /* BB map targetUNCs to dfs_info3 structures, here or
2274 in CIFSGetDFSRefer BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
2276 return rc;
2277}
2278
Jeff Layton09e50d52008-07-23 10:11:19 -04002279#ifdef CONFIG_DEBUG_LOCK_ALLOC
2280static struct lock_class_key cifs_key[2];
2281static struct lock_class_key cifs_slock_key[2];
2282
2283static inline void
2284cifs_reclassify_socket4(struct socket *sock)
2285{
2286 struct sock *sk = sock->sk;
2287 BUG_ON(sock_owned_by_user(sk));
2288 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2289 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2290}
2291
2292static inline void
2293cifs_reclassify_socket6(struct socket *sock)
2294{
2295 struct sock *sk = sock->sk;
2296 BUG_ON(sock_owned_by_user(sk));
2297 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2298 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2299}
2300#else
2301static inline void
2302cifs_reclassify_socket4(struct socket *sock)
2303{
2304}
2305
2306static inline void
2307cifs_reclassify_socket6(struct socket *sock)
2308{
2309}
2310#endif
2311
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002313static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314{
Steve French50c2f752007-07-13 00:33:32 +00002315 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316
Steve French50c2f752007-07-13 00:33:32 +00002317 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 /* mask a nibble at a time and encode */
2319 target[j] = 'A' + (0x0F & (source[i] >> 4));
2320 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002321 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 }
2323
2324}
2325
Ben Greear3eb9a882010-09-01 17:06:02 -07002326static int
2327bind_socket(struct TCP_Server_Info *server)
2328{
2329 int rc = 0;
2330 if (server->srcaddr.ss_family != AF_UNSPEC) {
2331 /* Bind to the specified local IP address */
2332 struct socket *socket = server->ssocket;
2333 rc = socket->ops->bind(socket,
2334 (struct sockaddr *) &server->srcaddr,
2335 sizeof(server->srcaddr));
2336 if (rc < 0) {
2337 struct sockaddr_in *saddr4;
2338 struct sockaddr_in6 *saddr6;
2339 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2340 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2341 if (saddr6->sin6_family == AF_INET6)
2342 cERROR(1, "cifs: "
2343 "Failed to bind to: %pI6c, error: %d\n",
2344 &saddr6->sin6_addr, rc);
2345 else
2346 cERROR(1, "cifs: "
2347 "Failed to bind to: %pI4, error: %d\n",
2348 &saddr4->sin_addr.s_addr, rc);
2349 }
2350 }
2351 return rc;
2352}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353
2354static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002355ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356{
2357 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002358 /*
2359 * some servers require RFC1001 sessinit before sending
2360 * negprot - BB check reconnection in case where second
2361 * sessinit is sent but no second negprot
2362 */
2363 struct rfc1002_session_packet *ses_init_buf;
2364 struct smb_hdr *smb_buf;
2365 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2366 GFP_KERNEL);
2367 if (ses_init_buf) {
2368 ses_init_buf->trailer.session_req.called_len = 32;
2369
2370 if (server->server_RFC1001_name &&
2371 server->server_RFC1001_name[0] != 0)
2372 rfc1002mangle(ses_init_buf->trailer.
2373 session_req.called_name,
2374 server->server_RFC1001_name,
2375 RFC1001_NAME_LEN_WITH_NULL);
2376 else
2377 rfc1002mangle(ses_init_buf->trailer.
2378 session_req.called_name,
2379 DEFAULT_CIFS_CALLED_NAME,
2380 RFC1001_NAME_LEN_WITH_NULL);
2381
2382 ses_init_buf->trailer.session_req.calling_len = 32;
2383
2384 /*
2385 * calling name ends in null (byte 16) from old smb
2386 * convention.
2387 */
2388 if (server->workstation_RFC1001_name &&
2389 server->workstation_RFC1001_name[0] != 0)
2390 rfc1002mangle(ses_init_buf->trailer.
2391 session_req.calling_name,
2392 server->workstation_RFC1001_name,
2393 RFC1001_NAME_LEN_WITH_NULL);
2394 else
2395 rfc1002mangle(ses_init_buf->trailer.
2396 session_req.calling_name,
2397 "LINUX_CIFS_CLNT",
2398 RFC1001_NAME_LEN_WITH_NULL);
2399
2400 ses_init_buf->trailer.session_req.scope1 = 0;
2401 ses_init_buf->trailer.session_req.scope2 = 0;
2402 smb_buf = (struct smb_hdr *)ses_init_buf;
2403
2404 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002405 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002406 rc = smb_send(server, smb_buf, 0x44);
2407 kfree(ses_init_buf);
2408 /*
2409 * RFC1001 layer in at least one server
2410 * requires very short break before negprot
2411 * presumably because not expecting negprot
2412 * to follow so fast. This is a simple
2413 * solution that works without
2414 * complicating the code and causes no
2415 * significant slowing down on mount
2416 * for everyone else
2417 */
2418 usleep_range(1000, 2000);
2419 }
2420 /*
2421 * else the negprot may still work without this
2422 * even though malloc failed
2423 */
2424
2425 return rc;
2426}
2427
2428static int
2429generic_ip_connect(struct TCP_Server_Info *server)
2430{
2431 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00002432 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002433 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002434 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002435 struct sockaddr *saddr;
2436
2437 saddr = (struct sockaddr *) &server->dstaddr;
2438
2439 if (server->dstaddr.ss_family == AF_INET6) {
2440 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2441 slen = sizeof(struct sockaddr_in6);
2442 sfamily = AF_INET6;
2443 } else {
2444 sport = ((struct sockaddr_in *) saddr)->sin_port;
2445 slen = sizeof(struct sockaddr_in);
2446 sfamily = AF_INET;
2447 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002449 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06002450 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2451 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 if (rc < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002453 cERROR(1, "Error %d creating socket", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002454 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002457
2458 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002459 cFYI(1, "Socket created");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002460 server->ssocket = socket;
2461 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002462 if (sfamily == AF_INET6)
2463 cifs_reclassify_socket6(socket);
2464 else
2465 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 }
2467
Ben Greear3eb9a882010-09-01 17:06:02 -07002468 rc = bind_socket(server);
2469 if (rc < 0)
2470 return rc;
2471
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002472 rc = socket->ops->connect(socket, saddr, slen, 0);
2473 if (rc < 0) {
2474 cFYI(1, "Error %d connecting to server", rc);
Jeff Laytond5c56052008-12-01 18:42:33 -05002475 sock_release(socket);
2476 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 return rc;
2478 }
Steve Frenchedf1ae42008-10-29 00:47:57 +00002479
Jeff Laytond5c56052008-12-01 18:42:33 -05002480 /*
2481 * Eventually check for other socket options to change from
2482 * the default. sock_setsockopt not used because it expects
2483 * user space buffer
2484 */
2485 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002486 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00002487
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002488 /* make the bufsizes depend on wsize/rsize and max requests */
2489 if (server->noautotune) {
2490 if (socket->sk->sk_sndbuf < (200 * 1024))
2491 socket->sk->sk_sndbuf = 200 * 1024;
2492 if (socket->sk->sk_rcvbuf < (140 * 1024))
2493 socket->sk->sk_rcvbuf = 140 * 1024;
2494 }
2495
Steve French6a5fa2362010-01-01 01:28:43 +00002496 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002497 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00002498 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2499 (char *)&val, sizeof(val));
2500 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002501 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002502 }
2503
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002504 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2505 socket->sk->sk_sndbuf,
2506 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2507
2508 if (sport == htons(RFC1001_PORT))
2509 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00002510
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 return rc;
2512}
2513
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002514static int
2515ip_connect(struct TCP_Server_Info *server)
2516{
Steve French6da97912011-03-13 18:55:55 +00002517 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002518 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2519 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2520
2521 if (server->dstaddr.ss_family == AF_INET6)
2522 sport = &addr6->sin6_port;
2523 else
2524 sport = &addr->sin_port;
2525
2526 if (*sport == 0) {
2527 int rc;
2528
2529 /* try with 445 port at first */
2530 *sport = htons(CIFS_PORT);
2531
2532 rc = generic_ip_connect(server);
2533 if (rc >= 0)
2534 return rc;
2535
2536 /* if it failed, try with 139 port */
2537 *sport = htons(RFC1001_PORT);
2538 }
2539
2540 return generic_ip_connect(server);
2541}
2542
Steve French50c2f752007-07-13 00:33:32 +00002543void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2544 struct super_block *sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00002545{
2546 /* if we are reconnecting then should we check to see if
2547 * any requested capabilities changed locally e.g. via
2548 * remount but we can not do much about it here
2549 * if they have (even if we could detect it by the following)
2550 * Perhaps we could add a backpointer to array of sb from tcon
2551 * or if we change to make all sb to same share the same
2552 * sb as NFS - then we only have one backpointer to sb.
2553 * What if we wanted to mount the server share twice once with
2554 * and once without posixacls or posix paths? */
2555 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00002556
Steve Frenchc18c8422007-07-18 23:21:09 +00002557 if (vol_info && vol_info->no_linux_ext) {
2558 tcon->fsUnixInfo.Capability = 0;
2559 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002560 cFYI(1, "Linux protocol extensions disabled");
Steve Frenchc18c8422007-07-18 23:21:09 +00002561 return;
2562 } else if (vol_info)
2563 tcon->unix_ext = 1; /* Unix Extensions supported */
2564
2565 if (tcon->unix_ext == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002566 cFYI(1, "Unix extensions disabled so not set on reconnect");
Steve Frenchc18c8422007-07-18 23:21:09 +00002567 return;
2568 }
Steve French50c2f752007-07-13 00:33:32 +00002569
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002570 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00002571 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French6848b732011-05-26 18:38:54 +00002572 cFYI(1, "unix caps which server supports %lld", cap);
Steve French8af18972007-02-14 04:42:51 +00002573 /* check for reconnect case in which we do not
2574 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002575 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002576 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00002577 originally at mount time */
2578 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2579 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002580 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2581 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002582 cERROR(1, "POSIXPATH support change");
Steve French8af18972007-02-14 04:42:51 +00002583 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00002584 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002585 cERROR(1, "possible reconnect error");
2586 cERROR(1, "server disabled POSIX path support");
Igor Mammedov11b6d642008-02-15 19:06:04 +00002587 }
Steve French8af18972007-02-14 04:42:51 +00002588 }
Steve French50c2f752007-07-13 00:33:32 +00002589
Steve French6848b732011-05-26 18:38:54 +00002590 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2591 cERROR(1, "per-share encryption not supported yet");
2592
Steve French8af18972007-02-14 04:42:51 +00002593 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00002594 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00002595 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002596 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002597 cFYI(1, "negotiated posix acl support");
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002598 if (sb)
Steve French8af18972007-02-14 04:42:51 +00002599 sb->s_flags |= MS_POSIXACL;
2600 }
2601
Steve French75865f8c2007-06-24 18:30:48 +00002602 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00002603 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00002604 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002605 cFYI(1, "negotiate posix pathnames");
Steve French75865f8c2007-06-24 18:30:48 +00002606 if (sb)
Steve French50c2f752007-07-13 00:33:32 +00002607 CIFS_SB(sb)->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00002608 CIFS_MOUNT_POSIX_PATHS;
2609 }
Steve French50c2f752007-07-13 00:33:32 +00002610
Steve French75865f8c2007-06-24 18:30:48 +00002611 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2612 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2613 CIFS_SB(sb)->rsize = 127 * 1024;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002614 cFYI(DBG2, "larger reads not supported by srv");
Steve French75865f8c2007-06-24 18:30:48 +00002615 }
2616 }
Steve French50c2f752007-07-13 00:33:32 +00002617
2618
Joe Perchesb6b38f72010-04-21 03:50:45 +00002619 cFYI(1, "Negotiate caps 0x%x", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00002620#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00002621 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002622 cFYI(1, "FCNTL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002623 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002624 cFYI(1, "EXTATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002625 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002626 cFYI(1, "POSIX path cap");
Steve French75865f8c2007-06-24 18:30:48 +00002627 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002628 cFYI(1, "XATTR cap");
Steve French75865f8c2007-06-24 18:30:48 +00002629 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002630 cFYI(1, "POSIX ACL cap");
Steve French75865f8c2007-06-24 18:30:48 +00002631 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002632 cFYI(1, "very large read cap");
Steve French75865f8c2007-06-24 18:30:48 +00002633 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002634 cFYI(1, "very large write cap");
Steve French6848b732011-05-26 18:38:54 +00002635 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2636 cFYI(1, "transport encryption cap");
2637 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2638 cFYI(1, "mandatory transport encryption cap");
Steve French8af18972007-02-14 04:42:51 +00002639#endif /* CIFS_DEBUG2 */
2640 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00002641 if (vol_info == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002642 cFYI(1, "resetting capabilities failed");
Steve French442aa312007-09-24 20:25:46 +00002643 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002644 cERROR(1, "Negotiating Unix capabilities "
Steve French5a44b312007-09-20 15:16:24 +00002645 "with the server failed. Consider "
2646 "mounting with the Unix Extensions\n"
2647 "disabled, if problems are found, "
2648 "by specifying the nounix mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00002649 "option.");
Steve French5a44b312007-09-20 15:16:24 +00002650
Steve French8af18972007-02-14 04:42:51 +00002651 }
2652 }
2653}
2654
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002655void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2656 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002657{
Jeff Layton2de970f2010-10-06 19:51:12 -04002658 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2659
Steve French3b795212008-11-13 19:45:32 +00002660 if (pvolume_info->rsize > CIFSMaxBufSize) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002661 cERROR(1, "rsize %d too large, using MaxBufSize",
2662 pvolume_info->rsize);
Steve French3b795212008-11-13 19:45:32 +00002663 cifs_sb->rsize = CIFSMaxBufSize;
2664 } else if ((pvolume_info->rsize) &&
2665 (pvolume_info->rsize <= CIFSMaxBufSize))
2666 cifs_sb->rsize = pvolume_info->rsize;
2667 else /* default */
2668 cifs_sb->rsize = CIFSMaxBufSize;
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002669
Steve French3b795212008-11-13 19:45:32 +00002670 if (cifs_sb->rsize < 2048) {
2671 cifs_sb->rsize = 2048;
2672 /* Windows ME may prefer this */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002673 cFYI(1, "readsize set to minimum: 2048");
Steve French3b795212008-11-13 19:45:32 +00002674 }
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002675
2676 /*
2677 * Temporarily set wsize for matching superblock. If we end up using
2678 * new sb then cifs_negotiate_wsize will later negotiate it downward
2679 * if needed.
2680 */
2681 cifs_sb->wsize = pvolume_info->wsize;
2682
Steve French3b795212008-11-13 19:45:32 +00002683 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2684 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2685 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2686 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002687 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2688 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00002689
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302690 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002691 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302692
Steve French3b795212008-11-13 19:45:32 +00002693 if (pvolume_info->noperm)
2694 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2695 if (pvolume_info->setuids)
2696 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2697 if (pvolume_info->server_ino)
2698 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2699 if (pvolume_info->remap)
2700 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2701 if (pvolume_info->no_xattr)
2702 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2703 if (pvolume_info->sfu_emul)
2704 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2705 if (pvolume_info->nobrl)
2706 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00002707 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00002708 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00002709 if (pvolume_info->mand_lock)
2710 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Steve French3b795212008-11-13 19:45:32 +00002711 if (pvolume_info->cifs_acl)
2712 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2713 if (pvolume_info->override_uid)
2714 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2715 if (pvolume_info->override_gid)
2716 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2717 if (pvolume_info->dynperm)
2718 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05302719 if (pvolume_info->fsc)
2720 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04002721 if (pvolume_info->multiuser)
2722 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2723 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05002724 if (pvolume_info->strict_io)
2725 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00002726 if (pvolume_info->direct_io) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002727 cFYI(1, "mounting share using direct i/o");
Steve French3b795212008-11-13 19:45:32 +00002728 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2729 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02002730 if (pvolume_info->mfsymlinks) {
2731 if (pvolume_info->sfu_emul) {
2732 cERROR(1, "mount option mfsymlinks ignored if sfu "
2733 "mount option is used");
2734 } else {
2735 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2736 }
2737 }
Steve French3b795212008-11-13 19:45:32 +00002738
2739 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesb6b38f72010-04-21 03:50:45 +00002740 cERROR(1, "mount option dynperm ignored if cifsacl "
2741 "mount option supported");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04002742}
2743
Jeff Laytonf7910cb2011-05-19 16:22:58 -04002744/*
2745 * When the server supports very large writes via POSIX extensions, we can
2746 * allow up to 2^24 - PAGE_CACHE_SIZE.
2747 *
2748 * Note that this might make for "interesting" allocation problems during
2749 * writeback however (as we have to allocate an array of pointers for the
2750 * pages). A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
2751 */
2752#define CIFS_MAX_WSIZE ((1<<24) - PAGE_CACHE_SIZE)
2753
2754/*
2755 * When the server doesn't allow large posix writes, default to a wsize of
2756 * 128k - PAGE_CACHE_SIZE -- one page less than the largest frame size
2757 * described in RFC1001. This allows space for the header without going over
2758 * that by default.
2759 */
2760#define CIFS_MAX_RFC1001_WSIZE (128 * 1024 - PAGE_CACHE_SIZE)
2761
2762/*
2763 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
2764 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
2765 * a single wsize request with a single call.
2766 */
2767#define CIFS_DEFAULT_WSIZE (1024 * 1024)
2768
2769static unsigned int
2770cifs_negotiate_wsize(struct cifsTconInfo *tcon, struct smb_vol *pvolume_info)
2771{
2772 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2773 struct TCP_Server_Info *server = tcon->ses->server;
2774 unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
2775 CIFS_DEFAULT_WSIZE;
2776
2777 /* can server support 24-bit write sizes? (via UNIX extensions) */
2778 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
2779 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1001_WSIZE);
2780
2781 /* no CAP_LARGE_WRITE_X? Limit it to 16 bits */
2782 if (!(server->capabilities & CAP_LARGE_WRITE_X))
2783 wsize = min_t(unsigned int, wsize, USHRT_MAX);
2784
2785 /* hard limit of CIFS_MAX_WSIZE */
2786 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
2787
2788 return wsize;
2789}
2790
Igor Mammedove4cce942009-02-10 14:10:26 +03002791static int
2792is_path_accessible(int xid, struct cifsTconInfo *tcon,
2793 struct cifs_sb_info *cifs_sb, const char *full_path)
2794{
2795 int rc;
Igor Mammedove4cce942009-02-10 14:10:26 +03002796 FILE_ALL_INFO *pfile_info;
2797
Igor Mammedove4cce942009-02-10 14:10:26 +03002798 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2799 if (pfile_info == NULL)
2800 return -ENOMEM;
2801
2802 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2803 0 /* not legacy */, cifs_sb->local_nls,
2804 cifs_sb->mnt_cifs_flags &
2805 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton221d1d72011-05-17 06:40:30 -04002806
2807 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2808 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2809 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2810 CIFS_MOUNT_MAP_SPECIAL_CHR);
Igor Mammedove4cce942009-02-10 14:10:26 +03002811 kfree(pfile_info);
2812 return rc;
2813}
2814
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002815void
2816cifs_cleanup_volume_info(struct smb_vol **pvolume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002817{
2818 struct smb_vol *volume_info;
2819
Dan Carpenterad6cca62010-04-26 12:10:06 +02002820 if (!pvolume_info || !*pvolume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002821 return;
2822
2823 volume_info = *pvolume_info;
Sean Finneyb9468452011-04-11 13:19:32 +00002824 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002825 kzfree(volume_info->password);
2826 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00002827 kfree(volume_info->UNCip);
2828 kfree(volume_info->domainname);
2829 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002830 kfree(volume_info->prepath);
2831 kfree(volume_info);
2832 *pvolume_info = NULL;
2833 return;
2834}
2835
Steve French2d6d5892009-04-09 00:36:44 +00002836#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002837/* build_path_to_root returns full path to root when
2838 * we do not have an exiting connection (tcon) */
2839static char *
2840build_unc_path_to_root(const struct smb_vol *volume_info,
2841 const struct cifs_sb_info *cifs_sb)
2842{
2843 char *full_path;
2844
2845 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
Steve Frenchf87d39d2011-05-27 03:50:55 +00002846 full_path = kmalloc(unc_len + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002847 if (full_path == NULL)
2848 return ERR_PTR(-ENOMEM);
2849
2850 strncpy(full_path, volume_info->UNC, unc_len);
Steve Frenchf87d39d2011-05-27 03:50:55 +00002851 full_path[unc_len] = 0; /* add trailing null */
2852 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002853 return full_path;
2854}
Sean Finneydd613942011-04-11 13:19:30 +00002855
2856/*
2857 * Perform a dfs referral query for a share and (optionally) prefix
2858 *
Sean Finney046462a2011-04-11 13:19:33 +00002859 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2860 * to a string containing updated options for the submount. Otherwise it
2861 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00002862 *
2863 * Returns the rc from get_dfs_path to the caller, which can be used to
2864 * determine whether there were referrals.
2865 */
2866static int
2867expand_dfs_referral(int xid, struct cifsSesInfo *pSesInfo,
2868 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00002869 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00002870{
2871 int rc;
2872 unsigned int num_referrals = 0;
2873 struct dfs_info3_param *referrals = NULL;
2874 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2875
2876 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2877 if (IS_ERR(full_path))
2878 return PTR_ERR(full_path);
2879
2880 /* For DFS paths, skip the first '\' of the UNC */
2881 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2882
2883 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2884 &num_referrals, &referrals,
2885 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2886
2887 if (!rc && num_referrals > 0) {
2888 char *fake_devname = NULL;
2889
2890 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2891 full_path + 1, referrals,
2892 &fake_devname);
2893
2894 free_dfs_info_array(referrals, num_referrals);
2895 kfree(fake_devname);
2896
Sean Finney046462a2011-04-11 13:19:33 +00002897 if (cifs_sb->mountdata != NULL)
2898 kfree(cifs_sb->mountdata);
2899
Sean Finneydd613942011-04-11 13:19:30 +00002900 if (IS_ERR(mdata)) {
2901 rc = PTR_ERR(mdata);
2902 mdata = NULL;
2903 }
Sean Finney046462a2011-04-11 13:19:33 +00002904 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00002905 }
2906 kfree(full_path);
2907 return rc;
2908}
Steve French2d6d5892009-04-09 00:36:44 +00002909#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04002910
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002911int cifs_setup_volume_info(struct smb_vol **pvolume_info, char *mount_data,
2912 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913{
Jeff Layton7586b762008-12-01 18:41:49 -05002914 struct smb_vol *volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002915 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00002916
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002917 *pvolume_info = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918
Jeff Layton7586b762008-12-01 18:41:49 -05002919 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2920 if (!volume_info) {
2921 rc = -ENOMEM;
2922 goto out;
2923 }
Steve French50c2f752007-07-13 00:33:32 +00002924
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002925 if (cifs_parse_mount_options(mount_data, devname,
Sean Finneyf14bcf72011-04-11 13:19:35 +00002926 volume_info)) {
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002927 rc = -EINVAL;
2928 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 }
2930
Jeff Layton7586b762008-12-01 18:41:49 -05002931 if (volume_info->nullauth) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002932 cFYI(1, "null user");
Jeff Layton7586b762008-12-01 18:41:49 -05002933 volume_info->username = "";
2934 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 /* BB fixme parse for domain name here */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002936 cFYI(1, "Username: %s", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 } else {
Steve Frenchbf820672005-12-01 22:32:42 -08002938 cifserror("No username specified");
Steve French50c2f752007-07-13 00:33:32 +00002939 /* In userspace mount helper we can get user name from alternate
2940 locations such as env variables and files on disk */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002941 rc = -EINVAL;
2942 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943 }
2944
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05002946 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002947 /* load_nls_default cannot return null */
2948 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04002950 volume_info->local_nls = load_nls(volume_info->iocharset);
2951 if (volume_info->local_nls == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002952 cERROR(1, "CIFS mount error: iocharset %s not found",
2953 volume_info->iocharset);
Jeff Layton70fe7dc2007-11-16 22:21:07 +00002954 rc = -ELIBACC;
2955 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00002958
2959 *pvolume_info = volume_info;
2960 return rc;
2961out:
2962 cifs_cleanup_volume_info(&volume_info);
2963 return rc;
2964}
2965
2966int
2967cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2968 struct smb_vol *volume_info, const char *devname)
2969{
2970 int rc = 0;
2971 int xid;
2972 struct cifsSesInfo *pSesInfo;
2973 struct cifsTconInfo *tcon;
2974 struct TCP_Server_Info *srvTcp;
2975 char *full_path;
2976 struct tcon_link *tlink;
2977#ifdef CONFIG_CIFS_DFS_UPCALL
2978 int referral_walks_count = 0;
2979try_mount_again:
2980 /* cleanup activities if we're chasing a referral */
2981 if (referral_walks_count) {
2982 if (tcon)
2983 cifs_put_tcon(tcon);
2984 else if (pSesInfo)
2985 cifs_put_smb_ses(pSesInfo);
2986
2987 cifs_cleanup_volume_info(&volume_info);
2988 FreeXid(xid);
2989 }
2990#endif
2991 tcon = NULL;
2992 pSesInfo = NULL;
2993 srvTcp = NULL;
2994 full_path = NULL;
2995 tlink = NULL;
2996
2997 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998
Jeff Layton63c038c2008-12-01 18:41:46 -05002999 /* get a reference to a tcp session */
Jeff Layton7586b762008-12-01 18:41:49 -05003000 srvTcp = cifs_get_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05003001 if (IS_ERR(srvTcp)) {
3002 rc = PTR_ERR(srvTcp);
3003 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 }
3005
Jeff Layton36988c72010-04-24 07:57:43 -04003006 /* get a reference to a SMB session */
3007 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3008 if (IS_ERR(pSesInfo)) {
3009 rc = PTR_ERR(pSesInfo);
3010 pSesInfo = NULL;
3011 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 }
Steve French50c2f752007-07-13 00:33:32 +00003013
Jeff Laytond00c28d2010-04-24 07:57:44 -04003014 if (pSesInfo->capabilities & CAP_LARGE_FILES)
3015 sb->s_maxbytes = MAX_LFS_FILESIZE;
3016 else
3017 sb->s_maxbytes = MAX_NON_LFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018
Steve French8af18972007-02-14 04:42:51 +00003019 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 sb->s_time_gran = 100;
3021
Jeff Laytond00c28d2010-04-24 07:57:44 -04003022 /* search for existing tcon to this server share */
3023 tcon = cifs_get_tcon(pSesInfo, volume_info);
3024 if (IS_ERR(tcon)) {
3025 rc = PTR_ERR(tcon);
3026 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003027 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003028 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003029
Steve French6848b732011-05-26 18:38:54 +00003030 /* tell server which Unix caps we support */
3031 if (tcon->ses->capabilities & CAP_UNIX) {
3032 /* reset of caps checks mount to see if unix extensions
3033 disabled for just this mount */
3034 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
3035 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3036 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3037 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3038 rc = -EACCES;
3039 goto mount_fail_check;
3040 }
3041 } else
3042 tcon->unix_ext = 0; /* server does not support them */
3043
Steve Frenchd82c2df2008-11-15 00:07:26 +00003044 /* do not care if following two calls succeed - informational */
3045 if (!tcon->ipc) {
3046 CIFSSMBQFSDeviceInfo(xid, tcon);
3047 CIFSSMBQFSAttributeInfo(xid, tcon);
3048 }
3049
Steve Frenchd82c2df2008-11-15 00:07:26 +00003050 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
3051 cifs_sb->rsize = 1024 * 127;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003052 cFYI(DBG2, "no very large read support, rsize now 127K");
Steve Frenchd82c2df2008-11-15 00:07:26 +00003053 }
Steve Frenchd82c2df2008-11-15 00:07:26 +00003054 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
3055 cifs_sb->rsize = min(cifs_sb->rsize,
3056 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003058 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3059
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003060remote_path_check:
Sean Finneyc1508ca2011-04-11 13:19:31 +00003061#ifdef CONFIG_CIFS_DFS_UPCALL
3062 /*
3063 * Perform an unconditional check for whether there are DFS
3064 * referrals for this path without prefix, to provide support
3065 * for DFS referrals from w2k8 servers which don't seem to respond
3066 * with PATH_NOT_COVERED to requests that include the prefix.
3067 * Chase the referral if found, otherwise continue normally.
3068 */
3069 if (referral_walks_count == 0) {
3070 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
Sean Finney046462a2011-04-11 13:19:33 +00003071 cifs_sb, false);
Sean Finneyc1508ca2011-04-11 13:19:31 +00003072 if (!refrc) {
3073 referral_walks_count++;
3074 goto try_mount_again;
3075 }
3076 }
3077#endif
3078
Steve Frenchf87d39d2011-05-27 03:50:55 +00003079 /* check if a whole path is not remote */
Jeff Layton70945642011-03-14 13:48:08 -04003080 if (!rc && tcon) {
Igor Mammedove4cce942009-02-10 14:10:26 +03003081 /* build_path_to_root works only when we have a valid tcon */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003082 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Igor Mammedove4cce942009-02-10 14:10:26 +03003083 if (full_path == NULL) {
3084 rc = -ENOMEM;
3085 goto mount_fail_check;
3086 }
3087 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
Jeff Layton03ceace2010-12-06 21:07:33 -05003088 if (rc != 0 && rc != -EREMOTE) {
Igor Mammedove4cce942009-02-10 14:10:26 +03003089 kfree(full_path);
3090 goto mount_fail_check;
3091 }
3092 kfree(full_path);
3093 }
3094
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003095 /* get referral if needed */
3096 if (rc == -EREMOTE) {
Steve Frenchd036f502009-04-03 03:12:08 +00003097#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003098 if (referral_walks_count > MAX_NESTED_LINKS) {
3099 /*
3100 * BB: when we implement proper loop detection,
3101 * we will remove this check. But now we need it
3102 * to prevent an indefinite loop if 'DFS tree' is
3103 * misconfigured (i.e. has loops).
3104 */
3105 rc = -ELOOP;
3106 goto mount_fail_check;
3107 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003108
Sean Finneydd613942011-04-11 13:19:30 +00003109 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003110 true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003111
Sean Finneydd613942011-04-11 13:19:30 +00003112 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003113 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003114 goto try_mount_again;
3115 }
Sean Finneydd613942011-04-11 13:19:30 +00003116 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003117#else /* No DFS support, return error on mount */
3118 rc = -EOPNOTSUPP;
3119#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003120 }
3121
Jeff Layton9d002df2010-10-06 19:51:11 -04003122 if (rc)
3123 goto mount_fail_check;
3124
3125 /* now, hang the tcon off of the superblock */
3126 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3127 if (tlink == NULL) {
3128 rc = -ENOMEM;
3129 goto mount_fail_check;
3130 }
3131
Jeff Laytonb647c352010-10-28 11:16:44 -04003132 tlink->tl_uid = pSesInfo->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003133 tlink->tl_tcon = tcon;
3134 tlink->tl_time = jiffies;
3135 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3136 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3137
Jeff Layton413e6612010-10-28 13:33:38 -04003138 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003139 spin_lock(&cifs_sb->tlink_tree_lock);
3140 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3141 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003142
Jeff Layton2de970f2010-10-06 19:51:12 -04003143 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3144 TLINK_IDLE_EXPIRE);
3145
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003146mount_fail_check:
3147 /* on error free sesinfo and tcon struct if needed */
3148 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003149 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003150 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003151 if (tcon)
3152 cifs_put_tcon(tcon);
3153 else if (pSesInfo)
3154 cifs_put_smb_ses(pSesInfo);
3155 else
3156 cifs_put_tcp_session(srvTcp);
3157 goto out;
3158 }
3159
Jeff Layton7586b762008-12-01 18:41:49 -05003160 /* volume_info->password is freed above when existing session found
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161 (in which case it is not needed anymore) but when new sesion is created
3162 the password ptr is put in the new session structure (in which case the
3163 password will be freed at unmount time) */
Jeff Layton70fe7dc2007-11-16 22:21:07 +00003164out:
3165 /* zero out password before freeing */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166 FreeXid(xid);
3167 return rc;
3168}
3169
Linus Torvalds1da177e2005-04-16 15:20:36 -07003170int
3171CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3172 const char *tree, struct cifsTconInfo *tcon,
3173 const struct nls_table *nls_codepage)
3174{
3175 struct smb_hdr *smb_buffer;
3176 struct smb_hdr *smb_buffer_response;
3177 TCONX_REQ *pSMB;
3178 TCONX_RSP *pSMBr;
3179 unsigned char *bcc_ptr;
3180 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003181 int length;
3182 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183
3184 if (ses == NULL)
3185 return -EIO;
3186
3187 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003188 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003190
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 smb_buffer_response = smb_buffer;
3192
3193 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3194 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003195
3196 smb_buffer->Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197 smb_buffer->Uid = ses->Suid;
3198 pSMB = (TCONX_REQ *) smb_buffer;
3199 pSMBr = (TCONX_RSP *) smb_buffer_response;
3200
3201 pSMB->AndXCommand = 0xFF;
3202 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 bcc_ptr = &pSMB->Password[0];
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003204 if ((ses->server->secMode) & SECMODE_USER) {
Steve Frencheeac8042006-01-13 21:34:58 -08003205 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003206 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003207 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003208 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003209 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003210 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003211 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3212 specified as required (when that support is added to
3213 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003214 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003215 by Samba (not sure whether other servers allow
3216 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003217#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003218 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton00e485b2008-12-05 20:41:21 -05003219 (ses->server->secType == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003220 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003221 ses->server->secMode &
3222 SECMODE_PW_ENCRYPT ? true : false,
3223 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003224 else
3225#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003226 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3227 bcc_ptr);
Steve Frencheeac8042006-01-13 21:34:58 -08003228
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003229 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003230 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003231 /* must align unicode strings */
3232 *bcc_ptr = 0; /* null byte password */
3233 bcc_ptr++;
3234 }
Steve Frencheeac8042006-01-13 21:34:58 -08003235 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236
Steve French50c2f752007-07-13 00:33:32 +00003237 if (ses->server->secMode &
Steve Frencha878fb22006-05-30 18:04:19 +00003238 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3240
3241 if (ses->capabilities & CAP_STATUS32) {
3242 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3243 }
3244 if (ses->capabilities & CAP_DFS) {
3245 smb_buffer->Flags2 |= SMBFLG2_DFS;
3246 }
3247 if (ses->capabilities & CAP_UNICODE) {
3248 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3249 length =
Steve French50c2f752007-07-13 00:33:32 +00003250 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3251 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003252 (/* server len*/ + 256 /* share len */), nls_codepage);
3253 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 bcc_ptr += 2; /* skip trailing null */
3255 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003256 strcpy(bcc_ptr, tree);
3257 bcc_ptr += strlen(tree) + 1;
3258 }
3259 strcpy(bcc_ptr, "?????");
3260 bcc_ptr += strlen("?????");
3261 bcc_ptr += 1;
3262 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003263 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3264 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265 pSMB->ByteCount = cpu_to_le16(count);
3266
Steve French133672e2007-11-13 22:41:37 +00003267 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003268 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270 /* above now done in SendReceive */
3271 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003272 bool is_unicode;
3273
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003275 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276 tcon->tid = smb_buffer_response->Tid;
3277 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003278 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003279 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003280 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3281 is_unicode = true;
3282 else
3283 is_unicode = false;
3284
Jeff Laytoncc20c032009-04-30 07:16:21 -04003285
Steve French50c2f752007-07-13 00:33:32 +00003286 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003287 if (length == 3) {
3288 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3289 (bcc_ptr[2] == 'C')) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003290 cFYI(1, "IPC connection");
Steve French7f8ed422007-09-28 22:28:55 +00003291 tcon->ipc = 1;
3292 }
3293 } else if (length == 2) {
3294 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3295 /* the most common case */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003296 cFYI(1, "disk share connection");
Steve French7f8ed422007-09-28 22:28:55 +00003297 }
3298 }
Steve French50c2f752007-07-13 00:33:32 +00003299 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003300 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003302
3303 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003304 kfree(tcon->nativeFileSystem);
Steve Frenchd185cda2009-04-30 17:45:10 +00003305 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003306 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003307 nls_codepage);
3308
Joe Perchesb6b38f72010-04-21 03:50:45 +00003309 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003310
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003311 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003312 (smb_buffer_response->WordCount == 7))
3313 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003314 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3315 else
3316 tcon->Flags = 0;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003317 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003318 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003319 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 ses->ipc_tid = smb_buffer_response->Tid;
3321 }
3322
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003323 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 return rc;
3325}
3326
3327int
3328cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3329{
Jeff Laytonb647c352010-10-28 11:16:44 -04003330 struct rb_root *root = &cifs_sb->tlink_tree;
3331 struct rb_node *node;
3332 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333
Jeff Layton2de970f2010-10-06 19:51:12 -04003334 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3335
Jeff Laytonb647c352010-10-28 11:16:44 -04003336 spin_lock(&cifs_sb->tlink_tree_lock);
3337 while ((node = rb_first(root))) {
3338 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3339 cifs_get_tlink(tlink);
3340 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3341 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003342
Jeff Laytonb647c352010-10-28 11:16:44 -04003343 spin_unlock(&cifs_sb->tlink_tree_lock);
3344 cifs_put_tlink(tlink);
3345 spin_lock(&cifs_sb->tlink_tree_lock);
3346 }
3347 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003348
Jeff Layton9d002df2010-10-06 19:51:11 -04003349 return 0;
Steve French50c2f752007-07-13 00:33:32 +00003350}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351
Jeff Layton198b5682010-04-24 07:57:48 -04003352int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353{
3354 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003355 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356
Jeff Layton198b5682010-04-24 07:57:48 -04003357 /* only send once per connect */
3358 if (server->maxBuf != 0)
3359 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003360
Jeff Layton198b5682010-04-24 07:57:48 -04003361 rc = CIFSSMBNegotiate(xid, ses);
3362 if (rc == -EAGAIN) {
3363 /* retry only once on 1st time connection */
3364 rc = CIFSSMBNegotiate(xid, ses);
3365 if (rc == -EAGAIN)
3366 rc = -EHOSTDOWN;
3367 }
3368 if (rc == 0) {
3369 spin_lock(&GlobalMid_Lock);
3370 if (server->tcpStatus != CifsExiting)
3371 server->tcpStatus = CifsGood;
3372 else
3373 rc = -EHOSTDOWN;
3374 spin_unlock(&GlobalMid_Lock);
3375
Linus Torvalds1da177e2005-04-16 15:20:36 -07003376 }
Steve French26b994f2008-08-06 05:11:33 +00003377
Jeff Layton198b5682010-04-24 07:57:48 -04003378 return rc;
3379}
Steve French26b994f2008-08-06 05:11:33 +00003380
Jeff Layton198b5682010-04-24 07:57:48 -04003381
3382int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3383 struct nls_table *nls_info)
3384{
3385 int rc = 0;
3386 struct TCP_Server_Info *server = ses->server;
3387
3388 ses->flags = 0;
3389 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003390 if (linuxExtEnabled == 0)
Jeff Layton198b5682010-04-24 07:57:48 -04003391 ses->capabilities &= (~CAP_UNIX);
Steve French20418ac2009-04-30 16:13:32 +00003392
Joe Perchesb6b38f72010-04-21 03:50:45 +00003393 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3394 server->secMode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003395
Jeff Layton198b5682010-04-24 07:57:48 -04003396 rc = CIFS_SessSetup(xid, ses, nls_info);
Steve French26b994f2008-08-06 05:11:33 +00003397 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003398 cERROR(1, "Send error in SessSetup = %d", rc);
Steve French26b994f2008-08-06 05:11:33 +00003399 } else {
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003400 mutex_lock(&ses->server->srv_mutex);
3401 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003402 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003403 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003404 server->sequence_number = 0x2;
3405 server->session_estab = true;
3406 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003407 }
3408 mutex_unlock(&server->srv_mutex);
3409
Joe Perchesb6b38f72010-04-21 03:50:45 +00003410 cFYI(1, "CIFS Session Established successfully");
Steve French20418ac2009-04-30 16:13:32 +00003411 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003412 ses->status = CifsGood;
3413 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003414 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003415 }
3416
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003417 kfree(ses->auth_key.response);
3418 ses->auth_key.response = NULL;
3419 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003420 kfree(ses->ntlmssp);
3421 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003422
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 return rc;
3424}
3425
Steve Frenchd2445552010-10-08 03:38:46 +00003426static struct cifsTconInfo *
Jeff Layton9d002df2010-10-06 19:51:11 -04003427cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3428{
3429 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3430 struct cifsSesInfo *ses;
3431 struct cifsTconInfo *tcon = NULL;
3432 struct smb_vol *vol_info;
Steve French34c87902011-03-01 05:02:57 +00003433 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3434 /* We used to have this as MAX_USERNAME which is */
3435 /* way too big now (256 instead of 32) */
Jeff Layton9d002df2010-10-06 19:51:11 -04003436
3437 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3438 if (vol_info == NULL) {
3439 tcon = ERR_PTR(-ENOMEM);
3440 goto out;
3441 }
3442
3443 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3444 vol_info->username = username;
3445 vol_info->local_nls = cifs_sb->local_nls;
3446 vol_info->linux_uid = fsuid;
3447 vol_info->cred_uid = fsuid;
3448 vol_info->UNC = master_tcon->treeName;
3449 vol_info->retry = master_tcon->retry;
3450 vol_info->nocase = master_tcon->nocase;
3451 vol_info->local_lease = master_tcon->local_lease;
3452 vol_info->no_linux_ext = !master_tcon->unix_ext;
3453
3454 /* FIXME: allow for other secFlg settings */
3455 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3456
3457 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303458 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003459 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303460 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003461
3462 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3463 if (IS_ERR(ses)) {
3464 tcon = (struct cifsTconInfo *)ses;
3465 cifs_put_tcp_session(master_tcon->ses->server);
3466 goto out;
3467 }
3468
3469 tcon = cifs_get_tcon(ses, vol_info);
3470 if (IS_ERR(tcon)) {
3471 cifs_put_smb_ses(ses);
3472 goto out;
3473 }
3474
3475 if (ses->capabilities & CAP_UNIX)
3476 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3477out:
3478 kfree(vol_info);
3479
3480 return tcon;
3481}
3482
Jeff Layton413e6612010-10-28 13:33:38 -04003483static inline struct tcon_link *
Jeff Layton9d002df2010-10-06 19:51:11 -04003484cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3485{
Jeff Layton413e6612010-10-28 13:33:38 -04003486 return cifs_sb->master_tlink;
Jeff Layton9d002df2010-10-06 19:51:11 -04003487}
3488
3489struct cifsTconInfo *
3490cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3491{
3492 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3493}
3494
3495static int
3496cifs_sb_tcon_pending_wait(void *unused)
3497{
3498 schedule();
3499 return signal_pending(current) ? -ERESTARTSYS : 0;
3500}
3501
Jeff Laytonb647c352010-10-28 11:16:44 -04003502/* find and return a tlink with given uid */
3503static struct tcon_link *
3504tlink_rb_search(struct rb_root *root, uid_t uid)
3505{
3506 struct rb_node *node = root->rb_node;
3507 struct tcon_link *tlink;
3508
3509 while (node) {
3510 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3511
3512 if (tlink->tl_uid > uid)
3513 node = node->rb_left;
3514 else if (tlink->tl_uid < uid)
3515 node = node->rb_right;
3516 else
3517 return tlink;
3518 }
3519 return NULL;
3520}
3521
3522/* insert a tcon_link into the tree */
3523static void
3524tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3525{
3526 struct rb_node **new = &(root->rb_node), *parent = NULL;
3527 struct tcon_link *tlink;
3528
3529 while (*new) {
3530 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3531 parent = *new;
3532
3533 if (tlink->tl_uid > new_tlink->tl_uid)
3534 new = &((*new)->rb_left);
3535 else
3536 new = &((*new)->rb_right);
3537 }
3538
3539 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3540 rb_insert_color(&new_tlink->tl_rbnode, root);
3541}
3542
Jeff Layton9d002df2010-10-06 19:51:11 -04003543/*
3544 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3545 * current task.
3546 *
3547 * If the superblock doesn't refer to a multiuser mount, then just return
3548 * the master tcon for the mount.
3549 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05303550 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04003551 * exists, then check to see if it's pending construction. If it is then wait
3552 * for construction to complete. Once it's no longer pending, check to see if
3553 * it failed and either return an error or retry construction, depending on
3554 * the timeout.
3555 *
3556 * If one doesn't exist then insert a new tcon_link struct into the tree and
3557 * try to construct a new one.
3558 */
3559struct tcon_link *
3560cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3561{
3562 int ret;
Jeff Laytonb647c352010-10-28 11:16:44 -04003563 uid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04003564 struct tcon_link *tlink, *newtlink;
3565
3566 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3567 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3568
3569 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003570 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003571 if (tlink)
3572 cifs_get_tlink(tlink);
3573 spin_unlock(&cifs_sb->tlink_tree_lock);
3574
3575 if (tlink == NULL) {
3576 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3577 if (newtlink == NULL)
3578 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04003579 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003580 newtlink->tl_tcon = ERR_PTR(-EACCES);
3581 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3582 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3583 cifs_get_tlink(newtlink);
3584
Jeff Layton9d002df2010-10-06 19:51:11 -04003585 spin_lock(&cifs_sb->tlink_tree_lock);
3586 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04003587 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04003588 if (tlink) {
3589 cifs_get_tlink(tlink);
3590 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003591 kfree(newtlink);
3592 goto wait_for_construction;
3593 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003594 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003595 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3596 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003597 } else {
3598wait_for_construction:
3599 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3600 cifs_sb_tcon_pending_wait,
3601 TASK_INTERRUPTIBLE);
3602 if (ret) {
3603 cifs_put_tlink(tlink);
3604 return ERR_PTR(ret);
3605 }
3606
3607 /* if it's good, return it */
3608 if (!IS_ERR(tlink->tl_tcon))
3609 return tlink;
3610
3611 /* return error if we tried this already recently */
3612 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3613 cifs_put_tlink(tlink);
3614 return ERR_PTR(-EACCES);
3615 }
3616
3617 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3618 goto wait_for_construction;
3619 }
3620
3621 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3622 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3623 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3624
3625 if (IS_ERR(tlink->tl_tcon)) {
3626 cifs_put_tlink(tlink);
3627 return ERR_PTR(-EACCES);
3628 }
3629
3630 return tlink;
3631}
Jeff Layton2de970f2010-10-06 19:51:12 -04003632
3633/*
3634 * periodic workqueue job that scans tcon_tree for a superblock and closes
3635 * out tcons.
3636 */
3637static void
3638cifs_prune_tlinks(struct work_struct *work)
3639{
3640 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3641 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04003642 struct rb_root *root = &cifs_sb->tlink_tree;
3643 struct rb_node *node = rb_first(root);
3644 struct rb_node *tmp;
3645 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04003646
Jeff Laytonb647c352010-10-28 11:16:44 -04003647 /*
3648 * Because we drop the spinlock in the loop in order to put the tlink
3649 * it's not guarded against removal of links from the tree. The only
3650 * places that remove entries from the tree are this function and
3651 * umounts. Because this function is non-reentrant and is canceled
3652 * before umount can proceed, this is safe.
3653 */
3654 spin_lock(&cifs_sb->tlink_tree_lock);
3655 node = rb_first(root);
3656 while (node != NULL) {
3657 tmp = node;
3658 node = rb_next(tmp);
3659 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3660
3661 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3662 atomic_read(&tlink->tl_count) != 0 ||
3663 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3664 continue;
3665
3666 cifs_get_tlink(tlink);
3667 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3668 rb_erase(tmp, root);
3669
Jeff Layton2de970f2010-10-06 19:51:12 -04003670 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04003671 cifs_put_tlink(tlink);
3672 spin_lock(&cifs_sb->tlink_tree_lock);
3673 }
3674 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04003675
3676 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3677 TLINK_IDLE_EXPIRE);
3678}