?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid beyond bounds copy while caching ACL
[zen-stable.git] / fs / cifs / connect.c
blob0ac595c8c2624fec58daac1c38479144333f5d7a
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2009
5 * 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
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
42 #include <net/ipv6.h>
43 #include "cifspdu.h"
44 #include "cifsglob.h"
45 #include "cifsproto.h"
46 #include "cifs_unicode.h"
47 #include "cifs_debug.h"
48 #include "cifs_fs_sb.h"
49 #include "ntlmssp.h"
50 #include "nterr.h"
51 #include "rfc1002pdu.h"
52 #include "fscache.h"
53
54 #define CIFS_PORT 445
55 #define RFC1001_PORT 139
56
57 /* SMB echo "timeout" -- FIXME: tunable? */
58 #define SMB_ECHO_INTERVAL (60 * HZ)
59
60 extern mempool_t *cifs_req_poolp;
61
62 /* FIXME: should these be tunable? */
63 #define TLINK_ERROR_EXPIRE (1 * HZ)
64 #define TLINK_IDLE_EXPIRE (600 * HZ)
65
66 static int ip_connect(struct TCP_Server_Info *server);
67 static int generic_ip_connect(struct TCP_Server_Info *server);
68 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
69 static void cifs_prune_tlinks(struct work_struct *work);
70 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
71 const char *devname);
72
73 /*
74 * cifs tcp session reconnection
75 *
76 * mark tcp session as reconnecting so temporarily locked
77 * mark all smb sessions as reconnecting for tcp session
78 * reconnect tcp session
79 * wake up waiters on reconnection? - (not needed currently)
80 */
81 static int
82 cifs_reconnect(struct TCP_Server_Info *server)
83 {
84 int rc = 0;
85 struct list_head *tmp, *tmp2;
86 struct cifs_ses *ses;
87 struct cifs_tcon *tcon;
88 struct mid_q_entry *mid_entry;
89 struct list_head retry_list;
90
91 spin_lock(&GlobalMid_Lock);
92 if (server->tcpStatus == CifsExiting) {
93 /* the demux thread will exit normally
94 next time through the loop */
95 spin_unlock(&GlobalMid_Lock);
96 return rc;
97 } else
98 server->tcpStatus = CifsNeedReconnect;
99 spin_unlock(&GlobalMid_Lock);
100 server->maxBuf = 0;
101
102 cFYI(1, "Reconnecting tcp session");
103
104 /* before reconnecting the tcp session, mark the smb session (uid)
105 and the tid bad so they are not used until reconnected */
106 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
107 spin_lock(&cifs_tcp_ses_lock);
108 list_for_each(tmp, &server->smb_ses_list) {
109 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
110 ses->need_reconnect = true;
111 ses->ipc_tid = 0;
112 list_for_each(tmp2, &ses->tcon_list) {
113 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
114 tcon->need_reconnect = true;
115 }
116 }
117 spin_unlock(&cifs_tcp_ses_lock);
118
119 /* do not want to be sending data on a socket we are freeing */
120 cFYI(1, "%s: tearing down socket", __func__);
121 mutex_lock(&server->srv_mutex);
122 if (server->ssocket) {
123 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
124 server->ssocket->flags);
125 kernel_sock_shutdown(server->ssocket, SHUT_WR);
126 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
127 server->ssocket->state,
128 server->ssocket->flags);
129 sock_release(server->ssocket);
130 server->ssocket = NULL;
131 }
132 server->sequence_number = 0;
133 server->session_estab = false;
134 kfree(server->session_key.response);
135 server->session_key.response = NULL;
136 server->session_key.len = 0;
137 server->lstrp = jiffies;
138 mutex_unlock(&server->srv_mutex);
139
140 /* mark submitted MIDs for retry and issue callback */
141 INIT_LIST_HEAD(&retry_list);
142 cFYI(1, "%s: moving mids to private list", __func__);
143 spin_lock(&GlobalMid_Lock);
144 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
145 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
146 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
147 mid_entry->midState = MID_RETRY_NEEDED;
148 list_move(&mid_entry->qhead, &retry_list);
149 }
150 spin_unlock(&GlobalMid_Lock);
151
152 cFYI(1, "%s: issuing mid callbacks", __func__);
153 list_for_each_safe(tmp, tmp2, &retry_list) {
154 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
155 list_del_init(&mid_entry->qhead);
156 mid_entry->callback(mid_entry);
157 }
158
159 do {
160 try_to_freeze();
161
162 /* we should try only the port we connected to before */
163 rc = generic_ip_connect(server);
164 if (rc) {
165 cFYI(1, "reconnect error %d", rc);
166 msleep(3000);
167 } else {
168 atomic_inc(&tcpSesReconnectCount);
169 spin_lock(&GlobalMid_Lock);
170 if (server->tcpStatus != CifsExiting)
171 server->tcpStatus = CifsNeedNegotiate;
172 spin_unlock(&GlobalMid_Lock);
173 }
174 } while (server->tcpStatus == CifsNeedReconnect);
175
176 return rc;
177 }
178
179 /*
180 return codes:
181 0 not a transact2, or all data present
182 >0 transact2 with that much data missing
183 -EINVAL = invalid transact2
184
185 */
186 static int check2ndT2(struct smb_hdr *pSMB)
187 {
188 struct smb_t2_rsp *pSMBt;
189 int remaining;
190 __u16 total_data_size, data_in_this_rsp;
191
192 if (pSMB->Command != SMB_COM_TRANSACTION2)
193 return 0;
194
195 /* check for plausible wct, bcc and t2 data and parm sizes */
196 /* check for parm and data offset going beyond end of smb */
197 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
198 cFYI(1, "invalid transact2 word count");
199 return -EINVAL;
200 }
201
202 pSMBt = (struct smb_t2_rsp *)pSMB;
203
204 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
205 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
206
207 if (total_data_size == data_in_this_rsp)
208 return 0;
209 else if (total_data_size < data_in_this_rsp) {
210 cFYI(1, "total data %d smaller than data in frame %d",
211 total_data_size, data_in_this_rsp);
212 return -EINVAL;
213 }
214
215 remaining = total_data_size - data_in_this_rsp;
216
217 cFYI(1, "missing %d bytes from transact2, check next response",
218 remaining);
219 if (total_data_size > CIFSMaxBufSize) {
220 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
221 total_data_size, CIFSMaxBufSize);
222 return -EINVAL;
223 }
224 return remaining;
225 }
226
227 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
228 {
229 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)psecond;
230 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
231 char *data_area_of_tgt;
232 char *data_area_of_src;
233 int remaining;
234 unsigned int byte_count, total_in_tgt;
235 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
236
237 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
238 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
239
240 if (tgt_total_cnt != src_total_cnt)
241 cFYI(1, "total data count of primary and secondary t2 differ "
242 "source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
243
244 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
245
246 remaining = tgt_total_cnt - total_in_tgt;
247
248 if (remaining < 0) {
249 cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
250 "total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
251 return -EPROTO;
252 }
253
254 if (remaining == 0) {
255 /* nothing to do, ignore */
256 cFYI(1, "no more data remains");
257 return 0;
258 }
259
260 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
261 if (remaining < total_in_src)
262 cFYI(1, "transact2 2nd response contains too much data");
263
264 /* find end of first SMB data area */
265 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
266 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
267
268 /* validate target area */
269 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
270 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
271
272 data_area_of_tgt += total_in_tgt;
273
274 total_in_tgt += total_in_src;
275 /* is the result too big for the field? */
276 if (total_in_tgt > USHRT_MAX) {
277 cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
278 return -EPROTO;
279 }
280 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
281
282 /* fix up the BCC */
283 byte_count = get_bcc(pTargetSMB);
284 byte_count += total_in_src;
285 /* is the result too big for the field? */
286 if (byte_count > USHRT_MAX) {
287 cFYI(1, "coalesced BCC too large (%u)", byte_count);
288 return -EPROTO;
289 }
290 put_bcc(byte_count, pTargetSMB);
291
292 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
293 byte_count += total_in_src;
294 /* don't allow buffer to overflow */
295 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
296 cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
297 return -ENOBUFS;
298 }
299 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
300
301 /* copy second buffer into end of first buffer */
302 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
303
304 if (remaining != total_in_src) {
305 /* more responses to go */
306 cFYI(1, "waiting for more secondary responses");
307 return 1;
308 }
309
310 /* we are done */
311 cFYI(1, "found the last secondary response");
312 return 0;
313 }
314
315 static void
316 cifs_echo_request(struct work_struct *work)
317 {
318 int rc;
319 struct TCP_Server_Info *server = container_of(work,
320 struct TCP_Server_Info, echo.work);
321
322 /*
323 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
324 * done, which is indicated by maxBuf != 0. Also, no need to ping if
325 * we got a response recently
326 */
327 if (server->maxBuf == 0 ||
328 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
329 goto requeue_echo;
330
331 rc = CIFSSMBEcho(server);
332 if (rc)
333 cFYI(1, "Unable to send echo request to server: %s",
334 server->hostname);
335
336 requeue_echo:
337 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
338 }
339
340 static bool
341 allocate_buffers(struct TCP_Server_Info *server)
342 {
343 if (!server->bigbuf) {
344 server->bigbuf = (char *)cifs_buf_get();
345 if (!server->bigbuf) {
346 cERROR(1, "No memory for large SMB response");
347 msleep(3000);
348 /* retry will check if exiting */
349 return false;
350 }
351 } else if (server->large_buf) {
352 /* we are reusing a dirty large buf, clear its start */
353 memset(server->bigbuf, 0, sizeof(struct smb_hdr));
354 }
355
356 if (!server->smallbuf) {
357 server->smallbuf = (char *)cifs_small_buf_get();
358 if (!server->smallbuf) {
359 cERROR(1, "No memory for SMB response");
360 msleep(1000);
361 /* retry will check if exiting */
362 return false;
363 }
364 /* beginning of smb buffer is cleared in our buf_get */
365 } else {
366 /* if existing small buf clear beginning */
367 memset(server->smallbuf, 0, sizeof(struct smb_hdr));
368 }
369
370 return true;
371 }
372
373 static bool
374 server_unresponsive(struct TCP_Server_Info *server)
375 {
376 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
377 time_after(jiffies, server->lstrp +
378 (echo_retries * SMB_ECHO_INTERVAL))) {
379 cERROR(1, "Server %s has not responded in %d seconds. "
380 "Reconnecting...", server->hostname,
381 (echo_retries * SMB_ECHO_INTERVAL / HZ));
382 cifs_reconnect(server);
383 wake_up(&server->response_q);
384 return true;
385 }
386
387 return false;
388 }
389
390 /*
391 * kvec_array_init - clone a kvec array, and advance into it
392 * @new: pointer to memory for cloned array
393 * @iov: pointer to original array
394 * @nr_segs: number of members in original array
395 * @bytes: number of bytes to advance into the cloned array
396 *
397 * This function will copy the array provided in iov to a section of memory
398 * and advance the specified number of bytes into the new array. It returns
399 * the number of segments in the new array. "new" must be at least as big as
400 * the original iov array.
401 */
402 static unsigned int
403 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
404 size_t bytes)
405 {
406 size_t base = 0;
407
408 while (bytes || !iov->iov_len) {
409 int copy = min(bytes, iov->iov_len);
410
411 bytes -= copy;
412 base += copy;
413 if (iov->iov_len == base) {
414 iov++;
415 nr_segs--;
416 base = 0;
417 }
418 }
419 memcpy(new, iov, sizeof(*iov) * nr_segs);
420 new->iov_base += base;
421 new->iov_len -= base;
422 return nr_segs;
423 }
424
425 static struct kvec *
426 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
427 {
428 struct kvec *new_iov;
429
430 if (server->iov && nr_segs <= server->nr_iov)
431 return server->iov;
432
433 /* not big enough -- allocate a new one and release the old */
434 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
435 if (new_iov) {
436 kfree(server->iov);
437 server->iov = new_iov;
438 server->nr_iov = nr_segs;
439 }
440 return new_iov;
441 }
442
443 int
444 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
445 unsigned int nr_segs, unsigned int to_read)
446 {
447 int length = 0;
448 int total_read;
449 unsigned int segs;
450 struct msghdr smb_msg;
451 struct kvec *iov;
452
453 iov = get_server_iovec(server, nr_segs);
454 if (!iov)
455 return -ENOMEM;
456
457 smb_msg.msg_control = NULL;
458 smb_msg.msg_controllen = 0;
459
460 for (total_read = 0; to_read; total_read += length, to_read -= length) {
461 try_to_freeze();
462
463 if (server_unresponsive(server)) {
464 total_read = -EAGAIN;
465 break;
466 }
467
468 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
469
470 length = kernel_recvmsg(server->ssocket, &smb_msg,
471 iov, segs, to_read, 0);
472
473 if (server->tcpStatus == CifsExiting) {
474 total_read = -ESHUTDOWN;
475 break;
476 } else if (server->tcpStatus == CifsNeedReconnect) {
477 cifs_reconnect(server);
478 total_read = -EAGAIN;
479 break;
480 } else if (length == -ERESTARTSYS ||
481 length == -EAGAIN ||
482 length == -EINTR) {
483 /*
484 * Minimum sleep to prevent looping, allowing socket
485 * to clear and app threads to set tcpStatus
486 * CifsNeedReconnect if server hung.
487 */
488 usleep_range(1000, 2000);
489 length = 0;
490 continue;
491 } else if (length <= 0) {
492 cFYI(1, "Received no data or error: expecting %d "
493 "got %d", to_read, length);
494 cifs_reconnect(server);
495 total_read = -EAGAIN;
496 break;
497 }
498 }
499 return total_read;
500 }
501
502 int
503 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
504 unsigned int to_read)
505 {
506 struct kvec iov;
507
508 iov.iov_base = buf;
509 iov.iov_len = to_read;
510
511 return cifs_readv_from_socket(server, &iov, 1, to_read);
512 }
513
514 static bool
515 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
516 {
517 /*
518 * The first byte big endian of the length field,
519 * is actually not part of the length but the type
520 * with the most common, zero, as regular data.
521 */
522 switch (type) {
523 case RFC1002_SESSION_MESSAGE:
524 /* Regular SMB response */
525 return true;
526 case RFC1002_SESSION_KEEP_ALIVE:
527 cFYI(1, "RFC 1002 session keep alive");
528 break;
529 case RFC1002_POSITIVE_SESSION_RESPONSE:
530 cFYI(1, "RFC 1002 positive session response");
531 break;
532 case RFC1002_NEGATIVE_SESSION_RESPONSE:
533 /*
534 * We get this from Windows 98 instead of an error on
535 * SMB negprot response.
536 */
537 cFYI(1, "RFC 1002 negative session response");
538 /* give server a second to clean up */
539 msleep(1000);
540 /*
541 * Always try 445 first on reconnect since we get NACK
542 * on some if we ever connected to port 139 (the NACK
543 * is since we do not begin with RFC1001 session
544 * initialize frame).
545 */
546 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
547 cifs_reconnect(server);
548 wake_up(&server->response_q);
549 break;
550 default:
551 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
552 cifs_reconnect(server);
553 }
554
555 return false;
556 }
557
558 static struct mid_q_entry *
559 find_mid(struct TCP_Server_Info *server, struct smb_hdr *buf)
560 {
561 struct mid_q_entry *mid;
562
563 spin_lock(&GlobalMid_Lock);
564 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
565 if (mid->mid == buf->Mid &&
566 mid->midState == MID_REQUEST_SUBMITTED &&
567 mid->command == buf->Command) {
568 spin_unlock(&GlobalMid_Lock);
569 return mid;
570 }
571 }
572 spin_unlock(&GlobalMid_Lock);
573 return NULL;
574 }
575
576 void
577 dequeue_mid(struct mid_q_entry *mid, bool malformed)
578 {
579 #ifdef CONFIG_CIFS_STATS2
580 mid->when_received = jiffies;
581 #endif
582 spin_lock(&GlobalMid_Lock);
583 if (!malformed)
584 mid->midState = MID_RESPONSE_RECEIVED;
585 else
586 mid->midState = MID_RESPONSE_MALFORMED;
587 list_del_init(&mid->qhead);
588 spin_unlock(&GlobalMid_Lock);
589 }
590
591 static void
592 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
593 struct smb_hdr *buf, int malformed)
594 {
595 if (malformed == 0 && check2ndT2(buf) > 0) {
596 mid->multiRsp = true;
597 if (mid->resp_buf) {
598 /* merge response - fix up 1st*/
599 malformed = coalesce_t2(buf, mid->resp_buf);
600 if (malformed > 0)
601 return;
602
603 /* All parts received or packet is malformed. */
604 mid->multiEnd = true;
605 return dequeue_mid(mid, malformed);
606 }
607 if (!server->large_buf) {
608 /*FIXME: switch to already allocated largebuf?*/
609 cERROR(1, "1st trans2 resp needs bigbuf");
610 } else {
611 /* Have first buffer */
612 mid->resp_buf = buf;
613 mid->largeBuf = true;
614 server->bigbuf = NULL;
615 }
616 return;
617 }
618 mid->resp_buf = buf;
619 mid->largeBuf = server->large_buf;
620 /* Was previous buf put in mpx struct for multi-rsp? */
621 if (!mid->multiRsp) {
622 /* smb buffer will be freed by user thread */
623 if (server->large_buf)
624 server->bigbuf = NULL;
625 else
626 server->smallbuf = NULL;
627 }
628 dequeue_mid(mid, malformed);
629 }
630
631 static void clean_demultiplex_info(struct TCP_Server_Info *server)
632 {
633 int length;
634
635 /* take it off the list, if it's not already */
636 spin_lock(&cifs_tcp_ses_lock);
637 list_del_init(&server->tcp_ses_list);
638 spin_unlock(&cifs_tcp_ses_lock);
639
640 spin_lock(&GlobalMid_Lock);
641 server->tcpStatus = CifsExiting;
642 spin_unlock(&GlobalMid_Lock);
643 wake_up_all(&server->response_q);
644
645 /* Check if we have blocked requests that need to free. */
646 spin_lock(&GlobalMid_Lock);
647 if (atomic_read(&server->inFlight) >= server->maxReq)
648 atomic_set(&server->inFlight, server->maxReq - 1);
649 /*
650 * We do not want to set the max_pending too low or we could end up
651 * with the counter going negative.
652 */
653 spin_unlock(&GlobalMid_Lock);
654 /*
655 * Although there should not be any requests blocked on this queue it
656 * can not hurt to be paranoid and try to wake up requests that may
657 * haven been blocked when more than 50 at time were on the wire to the
658 * same server - they now will see the session is in exit state and get
659 * out of SendReceive.
660 */
661 wake_up_all(&server->request_q);
662 /* give those requests time to exit */
663 msleep(125);
664
665 if (server->ssocket) {
666 sock_release(server->ssocket);
667 server->ssocket = NULL;
668 }
669
670 if (!list_empty(&server->pending_mid_q)) {
671 struct list_head dispose_list;
672 struct mid_q_entry *mid_entry;
673 struct list_head *tmp, *tmp2;
674
675 INIT_LIST_HEAD(&dispose_list);
676 spin_lock(&GlobalMid_Lock);
677 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
678 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
679 cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
680 mid_entry->midState = MID_SHUTDOWN;
681 list_move(&mid_entry->qhead, &dispose_list);
682 }
683 spin_unlock(&GlobalMid_Lock);
684
685 /* now walk dispose list and issue callbacks */
686 list_for_each_safe(tmp, tmp2, &dispose_list) {
687 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
688 cFYI(1, "Callback mid 0x%x", mid_entry->mid);
689 list_del_init(&mid_entry->qhead);
690 mid_entry->callback(mid_entry);
691 }
692 /* 1/8th of sec is more than enough time for them to exit */
693 msleep(125);
694 }
695
696 if (!list_empty(&server->pending_mid_q)) {
697 /*
698 * mpx threads have not exited yet give them at least the smb
699 * send timeout time for long ops.
700 *
701 * Due to delays on oplock break requests, we need to wait at
702 * least 45 seconds before giving up on a request getting a
703 * response and going ahead and killing cifsd.
704 */
705 cFYI(1, "Wait for exit from demultiplex thread");
706 msleep(46000);
707 /*
708 * If threads still have not exited they are probably never
709 * coming home not much else we can do but free the memory.
710 */
711 }
712
713 kfree(server->hostname);
714 kfree(server->iov);
715 kfree(server);
716
717 length = atomic_dec_return(&tcpSesAllocCount);
718 if (length > 0)
719 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
720 GFP_KERNEL);
721 }
722
723 static int
724 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
725 {
726 int length;
727 char *buf = server->smallbuf;
728 struct smb_hdr *smb_buffer = (struct smb_hdr *)buf;
729 unsigned int pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
730
731 /* make sure this will fit in a large buffer */
732 if (pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
733 cERROR(1, "SMB response too long (%u bytes)",
734 pdu_length);
735 cifs_reconnect(server);
736 wake_up(&server->response_q);
737 return -EAGAIN;
738 }
739
740 /* switch to large buffer if too big for a small one */
741 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
742 server->large_buf = true;
743 memcpy(server->bigbuf, server->smallbuf, server->total_read);
744 buf = server->bigbuf;
745 smb_buffer = (struct smb_hdr *)buf;
746 }
747
748 /* now read the rest */
749 length = cifs_read_from_socket(server,
750 buf + sizeof(struct smb_hdr) - 1,
751 pdu_length - sizeof(struct smb_hdr) + 1 + 4);
752 if (length < 0)
753 return length;
754 server->total_read += length;
755
756 dump_smb(smb_buffer, server->total_read);
757
758 /*
759 * We know that we received enough to get to the MID as we
760 * checked the pdu_length earlier. Now check to see
761 * if the rest of the header is OK. We borrow the length
762 * var for the rest of the loop to avoid a new stack var.
763 *
764 * 48 bytes is enough to display the header and a little bit
765 * into the payload for debugging purposes.
766 */
767 length = checkSMB(smb_buffer, smb_buffer->Mid, server->total_read);
768 if (length != 0)
769 cifs_dump_mem("Bad SMB: ", buf,
770 min_t(unsigned int, server->total_read, 48));
771
772 if (!mid)
773 return length;
774
775 handle_mid(mid, server, smb_buffer, length);
776 return 0;
777 }
778
779 static int
780 cifs_demultiplex_thread(void *p)
781 {
782 int length;
783 struct TCP_Server_Info *server = p;
784 unsigned int pdu_length;
785 char *buf = NULL;
786 struct smb_hdr *smb_buffer = NULL;
787 struct task_struct *task_to_wake = NULL;
788 struct mid_q_entry *mid_entry;
789
790 current->flags |= PF_MEMALLOC;
791 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
792
793 length = atomic_inc_return(&tcpSesAllocCount);
794 if (length > 1)
795 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
796 GFP_KERNEL);
797
798 set_freezable();
799 while (server->tcpStatus != CifsExiting) {
800 if (try_to_freeze())
801 continue;
802
803 if (!allocate_buffers(server))
804 continue;
805
806 server->large_buf = false;
807 smb_buffer = (struct smb_hdr *)server->smallbuf;
808 buf = server->smallbuf;
809 pdu_length = 4; /* enough to get RFC1001 header */
810
811 length = cifs_read_from_socket(server, buf, pdu_length);
812 if (length < 0)
813 continue;
814 server->total_read = length;
815
816 /*
817 * The right amount was read from socket - 4 bytes,
818 * so we can now interpret the length field.
819 */
820 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
821
822 cFYI(1, "RFC1002 header 0x%x", pdu_length);
823 if (!is_smb_response(server, buf[0]))
824 continue;
825
826 /* make sure we have enough to get to the MID */
827 if (pdu_length < sizeof(struct smb_hdr) - 1 - 4) {
828 cERROR(1, "SMB response too short (%u bytes)",
829 pdu_length);
830 cifs_reconnect(server);
831 wake_up(&server->response_q);
832 continue;
833 }
834
835 /* read down to the MID */
836 length = cifs_read_from_socket(server, buf + 4,
837 sizeof(struct smb_hdr) - 1 - 4);
838 if (length < 0)
839 continue;
840 server->total_read += length;
841
842 mid_entry = find_mid(server, smb_buffer);
843
844 if (!mid_entry || !mid_entry->receive)
845 length = standard_receive3(server, mid_entry);
846 else
847 length = mid_entry->receive(server, mid_entry);
848
849 if (length < 0)
850 continue;
851
852 if (server->large_buf) {
853 buf = server->bigbuf;
854 smb_buffer = (struct smb_hdr *)buf;
855 }
856
857 server->lstrp = jiffies;
858 if (mid_entry != NULL) {
859 if (!mid_entry->multiRsp || mid_entry->multiEnd)
860 mid_entry->callback(mid_entry);
861 } else if (!is_valid_oplock_break(smb_buffer, server)) {
862 cERROR(1, "No task to wake, unknown frame received! "
863 "NumMids %d", atomic_read(&midCount));
864 cifs_dump_mem("Received Data is: ", buf,
865 sizeof(struct smb_hdr));
866 #ifdef CONFIG_CIFS_DEBUG2
867 cifs_dump_detail(smb_buffer);
868 cifs_dump_mids(server);
869 #endif /* CIFS_DEBUG2 */
870
871 }
872 } /* end while !EXITING */
873
874 /* buffer usually freed in free_mid - need to free it here on exit */
875 cifs_buf_release(server->bigbuf);
876 if (server->smallbuf) /* no sense logging a debug message if NULL */
877 cifs_small_buf_release(server->smallbuf);
878
879 task_to_wake = xchg(&server->tsk, NULL);
880 clean_demultiplex_info(server);
881
882 /* if server->tsk was NULL then wait for a signal before exiting */
883 if (!task_to_wake) {
884 set_current_state(TASK_INTERRUPTIBLE);
885 while (!signal_pending(current)) {
886 schedule();
887 set_current_state(TASK_INTERRUPTIBLE);
888 }
889 set_current_state(TASK_RUNNING);
890 }
891
892 module_put_and_exit(0);
893 }
894
895 /* extract the host portion of the UNC string */
896 static char *
897 extract_hostname(const char *unc)
898 {
899 const char *src;
900 char *dst, *delim;
901 unsigned int len;
902
903 /* skip double chars at beginning of string */
904 /* BB: check validity of these bytes? */
905 src = unc + 2;
906
907 /* delimiter between hostname and sharename is always '\\' now */
908 delim = strchr(src, '\\');
909 if (!delim)
910 return ERR_PTR(-EINVAL);
911
912 len = delim - src;
913 dst = kmalloc((len + 1), GFP_KERNEL);
914 if (dst == NULL)
915 return ERR_PTR(-ENOMEM);
916
917 memcpy(dst, src, len);
918 dst[len] = '\0';
919
920 return dst;
921 }
922
923 static int
924 cifs_parse_mount_options(const char *mountdata, const char *devname,
925 struct smb_vol *vol)
926 {
927 char *value, *data, *end;
928 char *mountdata_copy = NULL, *options;
929 int err;
930 unsigned int temp_len, i, j;
931 char separator[2];
932 short int override_uid = -1;
933 short int override_gid = -1;
934 bool uid_specified = false;
935 bool gid_specified = false;
936 char *nodename = utsname()->nodename;
937
938 separator[0] = ',';
939 separator[1] = 0;
940
941 /*
942 * does not have to be perfect mapping since field is
943 * informational, only used for servers that do not support
944 * port 445 and it can be overridden at mount time
945 */
946 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
947 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
948 vol->source_rfc1001_name[i] = toupper(nodename[i]);
949
950 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
951 /* null target name indicates to use *SMBSERVR default called name
952 if we end up sending RFC1001 session initialize */
953 vol->target_rfc1001_name[0] = 0;
954 vol->cred_uid = current_uid();
955 vol->linux_uid = current_uid();
956 vol->linux_gid = current_gid();
957
958 /* default to only allowing write access to owner of the mount */
959 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
960
961 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
962 /* default is always to request posix paths. */
963 vol->posix_paths = 1;
964 /* default to using server inode numbers where available */
965 vol->server_ino = 1;
966
967 vol->actimeo = CIFS_DEF_ACTIMEO;
968
969 if (!mountdata)
970 goto cifs_parse_mount_err;
971
972 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
973 if (!mountdata_copy)
974 goto cifs_parse_mount_err;
975
976 options = mountdata_copy;
977 end = options + strlen(options);
978 if (strncmp(options, "sep=", 4) == 0) {
979 if (options[4] != 0) {
980 separator[0] = options[4];
981 options += 5;
982 } else {
983 cFYI(1, "Null separator not allowed");
984 }
985 }
986 vol->backupuid_specified = false; /* no backup intent for a user */
987 vol->backupgid_specified = false; /* no backup intent for a group */
988
989 while ((data = strsep(&options, separator)) != NULL) {
990 if (!*data)
991 continue;
992 if ((value = strchr(data, '=')) != NULL)
993 *value++ = '\0';
994
995 /* Have to parse this before we parse for "user" */
996 if (strnicmp(data, "user_xattr", 10) == 0) {
997 vol->no_xattr = 0;
998 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
999 vol->no_xattr = 1;
1000 } else if (strnicmp(data, "user", 4) == 0) {
1001 if (!value) {
1002 printk(KERN_WARNING
1003 "CIFS: invalid or missing username\n");
1004 goto cifs_parse_mount_err;
1005 } else if (!*value) {
1006 /* null user, ie anonymous, authentication */
1007 vol->nullauth = 1;
1008 }
1009 if (strnlen(value, MAX_USERNAME_SIZE) <
1010 MAX_USERNAME_SIZE) {
1011 vol->username = kstrdup(value, GFP_KERNEL);
1012 if (!vol->username) {
1013 printk(KERN_WARNING "CIFS: no memory "
1014 "for username\n");
1015 goto cifs_parse_mount_err;
1016 }
1017 } else {
1018 printk(KERN_WARNING "CIFS: username too long\n");
1019 goto cifs_parse_mount_err;
1020 }
1021 } else if (strnicmp(data, "pass", 4) == 0) {
1022 if (!value) {
1023 vol->password = NULL;
1024 continue;
1025 } else if (value[0] == 0) {
1026 /* check if string begins with double comma
1027 since that would mean the password really
1028 does start with a comma, and would not
1029 indicate an empty string */
1030 if (value[1] != separator[0]) {
1031 vol->password = NULL;
1032 continue;
1033 }
1034 }
1035 temp_len = strlen(value);
1036 /* removed password length check, NTLM passwords
1037 can be arbitrarily long */
1038
1039 /* if comma in password, the string will be
1040 prematurely null terminated. Commas in password are
1041 specified across the cifs mount interface by a double
1042 comma ie ,, and a comma used as in other cases ie ','
1043 as a parameter delimiter/separator is single and due
1044 to the strsep above is temporarily zeroed. */
1045
1046 /* NB: password legally can have multiple commas and
1047 the only illegal character in a password is null */
1048
1049 if ((value[temp_len] == 0) &&
1050 (value + temp_len < end) &&
1051 (value[temp_len+1] == separator[0])) {
1052 /* reinsert comma */
1053 value[temp_len] = separator[0];
1054 temp_len += 2; /* move after second comma */
1055 while (value[temp_len] != 0) {
1056 if (value[temp_len] == separator[0]) {
1057 if (value[temp_len+1] ==
1058 separator[0]) {
1059 /* skip second comma */
1060 temp_len++;
1061 } else {
1062 /* single comma indicating start
1063 of next parm */
1064 break;
1065 }
1066 }
1067 temp_len++;
1068 }
1069 if (value[temp_len] == 0) {
1070 options = NULL;
1071 } else {
1072 value[temp_len] = 0;
1073 /* point option to start of next parm */
1074 options = value + temp_len + 1;
1075 }
1076 /* go from value to value + temp_len condensing
1077 double commas to singles. Note that this ends up
1078 allocating a few bytes too many, which is ok */
1079 vol->password = kzalloc(temp_len, GFP_KERNEL);
1080 if (vol->password == NULL) {
1081 printk(KERN_WARNING "CIFS: no memory "
1082 "for password\n");
1083 goto cifs_parse_mount_err;
1084 }
1085 for (i = 0, j = 0; i < temp_len; i++, j++) {
1086 vol->password[j] = value[i];
1087 if (value[i] == separator[0]
1088 && value[i+1] == separator[0]) {
1089 /* skip second comma */
1090 i++;
1091 }
1092 }
1093 vol->password[j] = 0;
1094 } else {
1095 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1096 if (vol->password == NULL) {
1097 printk(KERN_WARNING "CIFS: no memory "
1098 "for password\n");
1099 goto cifs_parse_mount_err;
1100 }
1101 strcpy(vol->password, value);
1102 }
1103 } else if (!strnicmp(data, "ip", 2) ||
1104 !strnicmp(data, "addr", 4)) {
1105 if (!value || !*value) {
1106 vol->UNCip = NULL;
1107 } else if (strnlen(value, INET6_ADDRSTRLEN) <
1108 INET6_ADDRSTRLEN) {
1109 vol->UNCip = kstrdup(value, GFP_KERNEL);
1110 if (!vol->UNCip) {
1111 printk(KERN_WARNING "CIFS: no memory "
1112 "for UNC IP\n");
1113 goto cifs_parse_mount_err;
1114 }
1115 } else {
1116 printk(KERN_WARNING "CIFS: ip address "
1117 "too long\n");
1118 goto cifs_parse_mount_err;
1119 }
1120 } else if (strnicmp(data, "sec", 3) == 0) {
1121 if (!value || !*value) {
1122 cERROR(1, "no security value specified");
1123 continue;
1124 } else if (strnicmp(value, "krb5i", 5) == 0) {
1125 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1126 CIFSSEC_MUST_SIGN;
1127 } else if (strnicmp(value, "krb5p", 5) == 0) {
1128 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1129 CIFSSEC_MAY_KRB5; */
1130 cERROR(1, "Krb5 cifs privacy not supported");
1131 goto cifs_parse_mount_err;
1132 } else if (strnicmp(value, "krb5", 4) == 0) {
1133 vol->secFlg |= CIFSSEC_MAY_KRB5;
1134 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1135 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1136 CIFSSEC_MUST_SIGN;
1137 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1138 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1139 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1140 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1141 CIFSSEC_MUST_SIGN;
1142 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1143 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1144 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1145 vol->secFlg |= CIFSSEC_MAY_NTLM |
1146 CIFSSEC_MUST_SIGN;
1147 } else if (strnicmp(value, "ntlm", 4) == 0) {
1148 /* ntlm is default so can be turned off too */
1149 vol->secFlg |= CIFSSEC_MAY_NTLM;
1150 } else if (strnicmp(value, "nontlm", 6) == 0) {
1151 /* BB is there a better way to do this? */
1152 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1153 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1154 } else if (strnicmp(value, "lanman", 6) == 0) {
1155 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1156 #endif
1157 } else if (strnicmp(value, "none", 4) == 0) {
1158 vol->nullauth = 1;
1159 } else {
1160 cERROR(1, "bad security option: %s", value);
1161 goto cifs_parse_mount_err;
1162 }
1163 } else if (strnicmp(data, "vers", 3) == 0) {
1164 if (!value || !*value) {
1165 cERROR(1, "no protocol version specified"
1166 " after vers= mount option");
1167 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1168 (strnicmp(value, "1", 1) == 0)) {
1169 /* this is the default */
1170 continue;
1171 }
1172 } else if ((strnicmp(data, "unc", 3) == 0)
1173 || (strnicmp(data, "target", 6) == 0)
1174 || (strnicmp(data, "path", 4) == 0)) {
1175 if (!value || !*value) {
1176 printk(KERN_WARNING "CIFS: invalid path to "
1177 "network resource\n");
1178 goto cifs_parse_mount_err;
1179 }
1180 if ((temp_len = strnlen(value, 300)) < 300) {
1181 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1182 if (vol->UNC == NULL)
1183 goto cifs_parse_mount_err;
1184 strcpy(vol->UNC, value);
1185 if (strncmp(vol->UNC, "//", 2) == 0) {
1186 vol->UNC[0] = '\\';
1187 vol->UNC[1] = '\\';
1188 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1189 printk(KERN_WARNING
1190 "CIFS: UNC Path does not begin "
1191 "with // or \\\\ \n");
1192 goto cifs_parse_mount_err;
1193 }
1194 } else {
1195 printk(KERN_WARNING "CIFS: UNC name too long\n");
1196 goto cifs_parse_mount_err;
1197 }
1198 } else if ((strnicmp(data, "domain", 3) == 0)
1199 || (strnicmp(data, "workgroup", 5) == 0)) {
1200 if (!value || !*value) {
1201 printk(KERN_WARNING "CIFS: invalid domain name\n");
1202 goto cifs_parse_mount_err;
1203 }
1204 /* BB are there cases in which a comma can be valid in
1205 a domain name and need special handling? */
1206 if (strnlen(value, 256) < 256) {
1207 vol->domainname = kstrdup(value, GFP_KERNEL);
1208 if (!vol->domainname) {
1209 printk(KERN_WARNING "CIFS: no memory "
1210 "for domainname\n");
1211 goto cifs_parse_mount_err;
1212 }
1213 cFYI(1, "Domain name set");
1214 } else {
1215 printk(KERN_WARNING "CIFS: domain name too "
1216 "long\n");
1217 goto cifs_parse_mount_err;
1218 }
1219 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1220 vol->srcaddr.ss_family = AF_UNSPEC;
1221
1222 if (!value || !*value) {
1223 printk(KERN_WARNING "CIFS: srcaddr value"
1224 " not specified.\n");
1225 goto cifs_parse_mount_err;
1226 }
1227 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1228 value, strlen(value));
1229 if (i == 0) {
1230 printk(KERN_WARNING "CIFS: Could not parse"
1231 " srcaddr: %s\n",
1232 value);
1233 goto cifs_parse_mount_err;
1234 }
1235 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1236 if (!value || !*value) {
1237 printk(KERN_WARNING
1238 "CIFS: invalid path prefix\n");
1239 goto cifs_parse_mount_err;
1240 }
1241 if ((temp_len = strnlen(value, 1024)) < 1024) {
1242 if (value[0] != '/')
1243 temp_len++; /* missing leading slash */
1244 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1245 if (vol->prepath == NULL)
1246 goto cifs_parse_mount_err;
1247 if (value[0] != '/') {
1248 vol->prepath[0] = '/';
1249 strcpy(vol->prepath+1, value);
1250 } else
1251 strcpy(vol->prepath, value);
1252 cFYI(1, "prefix path %s", vol->prepath);
1253 } else {
1254 printk(KERN_WARNING "CIFS: prefix too long\n");
1255 goto cifs_parse_mount_err;
1256 }
1257 } else if (strnicmp(data, "iocharset", 9) == 0) {
1258 if (!value || !*value) {
1259 printk(KERN_WARNING "CIFS: invalid iocharset "
1260 "specified\n");
1261 goto cifs_parse_mount_err;
1262 }
1263 if (strnlen(value, 65) < 65) {
1264 if (strnicmp(value, "default", 7)) {
1265 vol->iocharset = kstrdup(value,
1266 GFP_KERNEL);
1267
1268 if (!vol->iocharset) {
1269 printk(KERN_WARNING "CIFS: no "
1270 "memory for"
1271 "charset\n");
1272 goto cifs_parse_mount_err;
1273 }
1274 }
1275 /* if iocharset not set then load_nls_default
1276 is used by caller */
1277 cFYI(1, "iocharset set to %s", value);
1278 } else {
1279 printk(KERN_WARNING "CIFS: iocharset name "
1280 "too long.\n");
1281 goto cifs_parse_mount_err;
1282 }
1283 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1284 vol->linux_uid = simple_strtoul(value, &value, 0);
1285 uid_specified = true;
1286 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1287 vol->cred_uid = simple_strtoul(value, &value, 0);
1288 } else if (!strnicmp(data, "forceuid", 8)) {
1289 override_uid = 1;
1290 } else if (!strnicmp(data, "noforceuid", 10)) {
1291 override_uid = 0;
1292 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1293 vol->linux_gid = simple_strtoul(value, &value, 0);
1294 gid_specified = true;
1295 } else if (!strnicmp(data, "forcegid", 8)) {
1296 override_gid = 1;
1297 } else if (!strnicmp(data, "noforcegid", 10)) {
1298 override_gid = 0;
1299 } else if (strnicmp(data, "file_mode", 4) == 0) {
1300 if (value && *value) {
1301 vol->file_mode =
1302 simple_strtoul(value, &value, 0);
1303 }
1304 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1305 if (value && *value) {
1306 vol->dir_mode =
1307 simple_strtoul(value, &value, 0);
1308 }
1309 } else if (strnicmp(data, "dirmode", 4) == 0) {
1310 if (value && *value) {
1311 vol->dir_mode =
1312 simple_strtoul(value, &value, 0);
1313 }
1314 } else if (strnicmp(data, "port", 4) == 0) {
1315 if (value && *value) {
1316 vol->port =
1317 simple_strtoul(value, &value, 0);
1318 }
1319 } else if (strnicmp(data, "rsize", 5) == 0) {
1320 if (value && *value) {
1321 vol->rsize =
1322 simple_strtoul(value, &value, 0);
1323 }
1324 } else if (strnicmp(data, "wsize", 5) == 0) {
1325 if (value && *value) {
1326 vol->wsize =
1327 simple_strtoul(value, &value, 0);
1328 }
1329 } else if (strnicmp(data, "sockopt", 5) == 0) {
1330 if (!value || !*value) {
1331 cERROR(1, "no socket option specified");
1332 continue;
1333 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1334 vol->sockopt_tcp_nodelay = 1;
1335 }
1336 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1337 if (!value || !*value || (*value == ' ')) {
1338 cFYI(1, "invalid (empty) netbiosname");
1339 } else {
1340 memset(vol->source_rfc1001_name, 0x20,
1341 RFC1001_NAME_LEN);
1342 /*
1343 * FIXME: are there cases in which a comma can
1344 * be valid in workstation netbios name (and
1345 * need special handling)?
1346 */
1347 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1348 /* don't ucase netbiosname for user */
1349 if (value[i] == 0)
1350 break;
1351 vol->source_rfc1001_name[i] = value[i];
1352 }
1353 /* The string has 16th byte zero still from
1354 set at top of the function */
1355 if (i == RFC1001_NAME_LEN && value[i] != 0)
1356 printk(KERN_WARNING "CIFS: netbiosname"
1357 " longer than 15 truncated.\n");
1358 }
1359 } else if (strnicmp(data, "servern", 7) == 0) {
1360 /* servernetbiosname specified override *SMBSERVER */
1361 if (!value || !*value || (*value == ' ')) {
1362 cFYI(1, "empty server netbiosname specified");
1363 } else {
1364 /* last byte, type, is 0x20 for servr type */
1365 memset(vol->target_rfc1001_name, 0x20,
1366 RFC1001_NAME_LEN_WITH_NULL);
1367
1368 for (i = 0; i < 15; i++) {
1369 /* BB are there cases in which a comma can be
1370 valid in this workstation netbios name
1371 (and need special handling)? */
1372
1373 /* user or mount helper must uppercase
1374 the netbiosname */
1375 if (value[i] == 0)
1376 break;
1377 else
1378 vol->target_rfc1001_name[i] =
1379 value[i];
1380 }
1381 /* The string has 16th byte zero still from
1382 set at top of the function */
1383 if (i == RFC1001_NAME_LEN && value[i] != 0)
1384 printk(KERN_WARNING "CIFS: server net"
1385 "biosname longer than 15 truncated.\n");
1386 }
1387 } else if (strnicmp(data, "actimeo", 7) == 0) {
1388 if (value && *value) {
1389 vol->actimeo = HZ * simple_strtoul(value,
1390 &value, 0);
1391 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1392 cERROR(1, "CIFS: attribute cache"
1393 "timeout too large");
1394 goto cifs_parse_mount_err;
1395 }
1396 }
1397 } else if (strnicmp(data, "credentials", 4) == 0) {
1398 /* ignore */
1399 } else if (strnicmp(data, "version", 3) == 0) {
1400 /* ignore */
1401 } else if (strnicmp(data, "guest", 5) == 0) {
1402 /* ignore */
1403 } else if (strnicmp(data, "rw", 2) == 0 && strlen(data) == 2) {
1404 /* ignore */
1405 } else if (strnicmp(data, "ro", 2) == 0) {
1406 /* ignore */
1407 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1408 vol->noblocksnd = 1;
1409 } else if (strnicmp(data, "noautotune", 10) == 0) {
1410 vol->noautotune = 1;
1411 } else if ((strnicmp(data, "suid", 4) == 0) ||
1412 (strnicmp(data, "nosuid", 6) == 0) ||
1413 (strnicmp(data, "exec", 4) == 0) ||
1414 (strnicmp(data, "noexec", 6) == 0) ||
1415 (strnicmp(data, "nodev", 5) == 0) ||
1416 (strnicmp(data, "noauto", 6) == 0) ||
1417 (strnicmp(data, "dev", 3) == 0)) {
1418 /* The mount tool or mount.cifs helper (if present)
1419 uses these opts to set flags, and the flags are read
1420 by the kernel vfs layer before we get here (ie
1421 before read super) so there is no point trying to
1422 parse these options again and set anything and it
1423 is ok to just ignore them */
1424 continue;
1425 } else if (strnicmp(data, "hard", 4) == 0) {
1426 vol->retry = 1;
1427 } else if (strnicmp(data, "soft", 4) == 0) {
1428 vol->retry = 0;
1429 } else if (strnicmp(data, "perm", 4) == 0) {
1430 vol->noperm = 0;
1431 } else if (strnicmp(data, "noperm", 6) == 0) {
1432 vol->noperm = 1;
1433 } else if (strnicmp(data, "mapchars", 8) == 0) {
1434 vol->remap = 1;
1435 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1436 vol->remap = 0;
1437 } else if (strnicmp(data, "sfu", 3) == 0) {
1438 vol->sfu_emul = 1;
1439 } else if (strnicmp(data, "nosfu", 5) == 0) {
1440 vol->sfu_emul = 0;
1441 } else if (strnicmp(data, "nodfs", 5) == 0) {
1442 vol->nodfs = 1;
1443 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1444 vol->posix_paths = 1;
1445 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1446 vol->posix_paths = 0;
1447 } else if (strnicmp(data, "nounix", 6) == 0) {
1448 vol->no_linux_ext = 1;
1449 } else if (strnicmp(data, "nolinux", 7) == 0) {
1450 vol->no_linux_ext = 1;
1451 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1452 (strnicmp(data, "ignorecase", 10) == 0)) {
1453 vol->nocase = 1;
1454 } else if (strnicmp(data, "mand", 4) == 0) {
1455 /* ignore */
1456 } else if (strnicmp(data, "nomand", 6) == 0) {
1457 /* ignore */
1458 } else if (strnicmp(data, "_netdev", 7) == 0) {
1459 /* ignore */
1460 } else if (strnicmp(data, "brl", 3) == 0) {
1461 vol->nobrl = 0;
1462 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1463 (strnicmp(data, "nolock", 6) == 0)) {
1464 vol->nobrl = 1;
1465 /* turn off mandatory locking in mode
1466 if remote locking is turned off since the
1467 local vfs will do advisory */
1468 if (vol->file_mode ==
1469 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1470 vol->file_mode = S_IALLUGO;
1471 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1472 /* will take the shorter form "forcemand" as well */
1473 /* This mount option will force use of mandatory
1474 (DOS/Windows style) byte range locks, instead of
1475 using posix advisory byte range locks, even if the
1476 Unix extensions are available and posix locks would
1477 be supported otherwise. If Unix extensions are not
1478 negotiated this has no effect since mandatory locks
1479 would be used (mandatory locks is all that those
1480 those servers support) */
1481 vol->mand_lock = 1;
1482 } else if (strnicmp(data, "setuids", 7) == 0) {
1483 vol->setuids = 1;
1484 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1485 vol->setuids = 0;
1486 } else if (strnicmp(data, "dynperm", 7) == 0) {
1487 vol->dynperm = true;
1488 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1489 vol->dynperm = false;
1490 } else if (strnicmp(data, "nohard", 6) == 0) {
1491 vol->retry = 0;
1492 } else if (strnicmp(data, "nosoft", 6) == 0) {
1493 vol->retry = 1;
1494 } else if (strnicmp(data, "nointr", 6) == 0) {
1495 vol->intr = 0;
1496 } else if (strnicmp(data, "intr", 4) == 0) {
1497 vol->intr = 1;
1498 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1499 vol->nostrictsync = 1;
1500 } else if (strnicmp(data, "strictsync", 10) == 0) {
1501 vol->nostrictsync = 0;
1502 } else if (strnicmp(data, "serverino", 7) == 0) {
1503 vol->server_ino = 1;
1504 } else if (strnicmp(data, "noserverino", 9) == 0) {
1505 vol->server_ino = 0;
1506 } else if (strnicmp(data, "rwpidforward", 12) == 0) {
1507 vol->rwpidforward = 1;
1508 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1509 vol->cifs_acl = 1;
1510 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1511 vol->cifs_acl = 0;
1512 } else if (strnicmp(data, "acl", 3) == 0) {
1513 vol->no_psx_acl = 0;
1514 } else if (strnicmp(data, "noacl", 5) == 0) {
1515 vol->no_psx_acl = 1;
1516 } else if (strnicmp(data, "locallease", 6) == 0) {
1517 vol->local_lease = 1;
1518 } else if (strnicmp(data, "sign", 4) == 0) {
1519 vol->secFlg |= CIFSSEC_MUST_SIGN;
1520 } else if (strnicmp(data, "seal", 4) == 0) {
1521 /* we do not do the following in secFlags because seal
1522 is a per tree connection (mount) not a per socket
1523 or per-smb connection option in the protocol */
1524 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1525 vol->seal = 1;
1526 } else if (strnicmp(data, "direct", 6) == 0) {
1527 vol->direct_io = 1;
1528 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1529 vol->direct_io = 1;
1530 } else if (strnicmp(data, "strictcache", 11) == 0) {
1531 vol->strict_io = 1;
1532 } else if (strnicmp(data, "noac", 4) == 0) {
1533 printk(KERN_WARNING "CIFS: Mount option noac not "
1534 "supported. Instead set "
1535 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1536 } else if (strnicmp(data, "fsc", 3) == 0) {
1537 #ifndef CONFIG_CIFS_FSCACHE
1538 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1539 "kernel config option set");
1540 goto cifs_parse_mount_err;
1541 #endif
1542 vol->fsc = true;
1543 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1544 vol->mfsymlinks = true;
1545 } else if (strnicmp(data, "multiuser", 8) == 0) {
1546 vol->multiuser = true;
1547 } else if (!strnicmp(data, "backupuid", 9) && value && *value) {
1548 err = kstrtouint(value, 0, &vol->backupuid);
1549 if (err < 0) {
1550 cERROR(1, "%s: Invalid backupuid value",
1551 __func__);
1552 goto cifs_parse_mount_err;
1553 }
1554 vol->backupuid_specified = true;
1555 } else if (!strnicmp(data, "backupgid", 9) && value && *value) {
1556 err = kstrtouint(value, 0, &vol->backupgid);
1557 if (err < 0) {
1558 cERROR(1, "%s: Invalid backupgid value",
1559 __func__);
1560 goto cifs_parse_mount_err;
1561 }
1562 vol->backupgid_specified = true;
1563 } else
1564 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1565 data);
1566 }
1567 if (vol->UNC == NULL) {
1568 if (devname == NULL) {
1569 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1570 "target\n");
1571 goto cifs_parse_mount_err;
1572 }
1573 if ((temp_len = strnlen(devname, 300)) < 300) {
1574 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1575 if (vol->UNC == NULL)
1576 goto cifs_parse_mount_err;
1577 strcpy(vol->UNC, devname);
1578 if (strncmp(vol->UNC, "//", 2) == 0) {
1579 vol->UNC[0] = '\\';
1580 vol->UNC[1] = '\\';
1581 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1582 printk(KERN_WARNING "CIFS: UNC Path does not "
1583 "begin with // or \\\\ \n");
1584 goto cifs_parse_mount_err;
1585 }
1586 value = strpbrk(vol->UNC+2, "/\\");
1587 if (value)
1588 *value = '\\';
1589 } else {
1590 printk(KERN_WARNING "CIFS: UNC name too long\n");
1591 goto cifs_parse_mount_err;
1592 }
1593 }
1594
1595 #ifndef CONFIG_KEYS
1596 /* Muliuser mounts require CONFIG_KEYS support */
1597 if (vol->multiuser) {
1598 cERROR(1, "Multiuser mounts require kernels with "
1599 "CONFIG_KEYS enabled.");
1600 goto cifs_parse_mount_err;
1601 }
1602 #endif
1603
1604 if (vol->UNCip == NULL)
1605 vol->UNCip = &vol->UNC[2];
1606
1607 if (uid_specified)
1608 vol->override_uid = override_uid;
1609 else if (override_uid == 1)
1610 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1611 "specified with no uid= option.\n");
1612
1613 if (gid_specified)
1614 vol->override_gid = override_gid;
1615 else if (override_gid == 1)
1616 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1617 "specified with no gid= option.\n");
1618
1619 kfree(mountdata_copy);
1620 return 0;
1621
1622 cifs_parse_mount_err:
1623 kfree(mountdata_copy);
1624 return 1;
1625 }
1626
1627 /** Returns true if srcaddr isn't specified and rhs isn't
1628 * specified, or if srcaddr is specified and
1629 * matches the IP address of the rhs argument.
1630 */
1631 static bool
1632 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1633 {
1634 switch (srcaddr->sa_family) {
1635 case AF_UNSPEC:
1636 return (rhs->sa_family == AF_UNSPEC);
1637 case AF_INET: {
1638 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1639 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1640 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1641 }
1642 case AF_INET6: {
1643 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1644 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1645 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1646 }
1647 default:
1648 WARN_ON(1);
1649 return false; /* don't expect to be here */
1650 }
1651 }
1652
1653 /*
1654 * If no port is specified in addr structure, we try to match with 445 port
1655 * and if it fails - with 139 ports. It should be called only if address
1656 * families of server and addr are equal.
1657 */
1658 static bool
1659 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1660 {
1661 __be16 port, *sport;
1662
1663 switch (addr->sa_family) {
1664 case AF_INET:
1665 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1666 port = ((struct sockaddr_in *) addr)->sin_port;
1667 break;
1668 case AF_INET6:
1669 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1670 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1671 break;
1672 default:
1673 WARN_ON(1);
1674 return false;
1675 }
1676
1677 if (!port) {
1678 port = htons(CIFS_PORT);
1679 if (port == *sport)
1680 return true;
1681
1682 port = htons(RFC1001_PORT);
1683 }
1684
1685 return port == *sport;
1686 }
1687
1688 static bool
1689 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1690 struct sockaddr *srcaddr)
1691 {
1692 switch (addr->sa_family) {
1693 case AF_INET: {
1694 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1695 struct sockaddr_in *srv_addr4 =
1696 (struct sockaddr_in *)&server->dstaddr;
1697
1698 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1699 return false;
1700 break;
1701 }
1702 case AF_INET6: {
1703 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1704 struct sockaddr_in6 *srv_addr6 =
1705 (struct sockaddr_in6 *)&server->dstaddr;
1706
1707 if (!ipv6_addr_equal(&addr6->sin6_addr,
1708 &srv_addr6->sin6_addr))
1709 return false;
1710 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1711 return false;
1712 break;
1713 }
1714 default:
1715 WARN_ON(1);
1716 return false; /* don't expect to be here */
1717 }
1718
1719 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1720 return false;
1721
1722 return true;
1723 }
1724
1725 static bool
1726 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1727 {
1728 unsigned int secFlags;
1729
1730 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1731 secFlags = vol->secFlg;
1732 else
1733 secFlags = global_secflags | vol->secFlg;
1734
1735 switch (server->secType) {
1736 case LANMAN:
1737 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1738 return false;
1739 break;
1740 case NTLMv2:
1741 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1742 return false;
1743 break;
1744 case NTLM:
1745 if (!(secFlags & CIFSSEC_MAY_NTLM))
1746 return false;
1747 break;
1748 case Kerberos:
1749 if (!(secFlags & CIFSSEC_MAY_KRB5))
1750 return false;
1751 break;
1752 case RawNTLMSSP:
1753 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1754 return false;
1755 break;
1756 default:
1757 /* shouldn't happen */
1758 return false;
1759 }
1760
1761 /* now check if signing mode is acceptable */
1762 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1763 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1764 return false;
1765 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1766 (server->sec_mode &
1767 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1768 return false;
1769
1770 return true;
1771 }
1772
1773 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1774 struct smb_vol *vol)
1775 {
1776 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1777 return 0;
1778
1779 if (!match_address(server, addr,
1780 (struct sockaddr *)&vol->srcaddr))
1781 return 0;
1782
1783 if (!match_port(server, addr))
1784 return 0;
1785
1786 if (!match_security(server, vol))
1787 return 0;
1788
1789 return 1;
1790 }
1791
1792 static struct TCP_Server_Info *
1793 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1794 {
1795 struct TCP_Server_Info *server;
1796
1797 spin_lock(&cifs_tcp_ses_lock);
1798 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1799 if (!match_server(server, addr, vol))
1800 continue;
1801
1802 ++server->srv_count;
1803 spin_unlock(&cifs_tcp_ses_lock);
1804 cFYI(1, "Existing tcp session with server found");
1805 return server;
1806 }
1807 spin_unlock(&cifs_tcp_ses_lock);
1808 return NULL;
1809 }
1810
1811 static void
1812 cifs_put_tcp_session(struct TCP_Server_Info *server)
1813 {
1814 struct task_struct *task;
1815
1816 spin_lock(&cifs_tcp_ses_lock);
1817 if (--server->srv_count > 0) {
1818 spin_unlock(&cifs_tcp_ses_lock);
1819 return;
1820 }
1821
1822 put_net(cifs_net_ns(server));
1823
1824 list_del_init(&server->tcp_ses_list);
1825 spin_unlock(&cifs_tcp_ses_lock);
1826
1827 cancel_delayed_work_sync(&server->echo);
1828
1829 spin_lock(&GlobalMid_Lock);
1830 server->tcpStatus = CifsExiting;
1831 spin_unlock(&GlobalMid_Lock);
1832
1833 cifs_crypto_shash_release(server);
1834 cifs_fscache_release_client_cookie(server);
1835
1836 kfree(server->session_key.response);
1837 server->session_key.response = NULL;
1838 server->session_key.len = 0;
1839
1840 task = xchg(&server->tsk, NULL);
1841 if (task)
1842 force_sig(SIGKILL, task);
1843 }
1844
1845 static struct TCP_Server_Info *
1846 cifs_get_tcp_session(struct smb_vol *volume_info)
1847 {
1848 struct TCP_Server_Info *tcp_ses = NULL;
1849 struct sockaddr_storage addr;
1850 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1851 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1852 int rc;
1853
1854 memset(&addr, 0, sizeof(struct sockaddr_storage));
1855
1856 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1857
1858 if (volume_info->UNCip && volume_info->UNC) {
1859 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1860 volume_info->UNCip,
1861 strlen(volume_info->UNCip),
1862 volume_info->port);
1863 if (!rc) {
1864 /* we failed translating address */
1865 rc = -EINVAL;
1866 goto out_err;
1867 }
1868 } else if (volume_info->UNCip) {
1869 /* BB using ip addr as tcp_ses name to connect to the
1870 DFS root below */
1871 cERROR(1, "Connecting to DFS root not implemented yet");
1872 rc = -EINVAL;
1873 goto out_err;
1874 } else /* which tcp_sess DFS root would we conect to */ {
1875 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1876 "unc=//192.168.1.100/public) specified");
1877 rc = -EINVAL;
1878 goto out_err;
1879 }
1880
1881 /* see if we already have a matching tcp_ses */
1882 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1883 if (tcp_ses)
1884 return tcp_ses;
1885
1886 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1887 if (!tcp_ses) {
1888 rc = -ENOMEM;
1889 goto out_err;
1890 }
1891
1892 rc = cifs_crypto_shash_allocate(tcp_ses);
1893 if (rc) {
1894 cERROR(1, "could not setup hash structures rc %d", rc);
1895 goto out_err;
1896 }
1897
1898 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1899 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1900 if (IS_ERR(tcp_ses->hostname)) {
1901 rc = PTR_ERR(tcp_ses->hostname);
1902 goto out_err_crypto_release;
1903 }
1904
1905 tcp_ses->noblocksnd = volume_info->noblocksnd;
1906 tcp_ses->noautotune = volume_info->noautotune;
1907 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1908 atomic_set(&tcp_ses->inFlight, 0);
1909 tcp_ses->maxReq = 1; /* enough to send negotiate request */
1910 init_waitqueue_head(&tcp_ses->response_q);
1911 init_waitqueue_head(&tcp_ses->request_q);
1912 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1913 mutex_init(&tcp_ses->srv_mutex);
1914 memcpy(tcp_ses->workstation_RFC1001_name,
1915 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1916 memcpy(tcp_ses->server_RFC1001_name,
1917 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1918 tcp_ses->session_estab = false;
1919 tcp_ses->sequence_number = 0;
1920 tcp_ses->lstrp = jiffies;
1921 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1922 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1923 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1924
1925 /*
1926 * at this point we are the only ones with the pointer
1927 * to the struct since the kernel thread not created yet
1928 * no need to spinlock this init of tcpStatus or srv_count
1929 */
1930 tcp_ses->tcpStatus = CifsNew;
1931 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1932 sizeof(tcp_ses->srcaddr));
1933 ++tcp_ses->srv_count;
1934
1935 if (addr.ss_family == AF_INET6) {
1936 cFYI(1, "attempting ipv6 connect");
1937 /* BB should we allow ipv6 on port 139? */
1938 /* other OS never observed in Wild doing 139 with v6 */
1939 memcpy(&tcp_ses->dstaddr, sin_server6,
1940 sizeof(struct sockaddr_in6));
1941 } else
1942 memcpy(&tcp_ses->dstaddr, sin_server,
1943 sizeof(struct sockaddr_in));
1944
1945 rc = ip_connect(tcp_ses);
1946 if (rc < 0) {
1947 cERROR(1, "Error connecting to socket. Aborting operation");
1948 goto out_err_crypto_release;
1949 }
1950
1951 /*
1952 * since we're in a cifs function already, we know that
1953 * this will succeed. No need for try_module_get().
1954 */
1955 __module_get(THIS_MODULE);
1956 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1957 tcp_ses, "cifsd");
1958 if (IS_ERR(tcp_ses->tsk)) {
1959 rc = PTR_ERR(tcp_ses->tsk);
1960 cERROR(1, "error %d create cifsd thread", rc);
1961 module_put(THIS_MODULE);
1962 goto out_err_crypto_release;
1963 }
1964 tcp_ses->tcpStatus = CifsNeedNegotiate;
1965
1966 /* thread spawned, put it on the list */
1967 spin_lock(&cifs_tcp_ses_lock);
1968 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1969 spin_unlock(&cifs_tcp_ses_lock);
1970
1971 cifs_fscache_get_client_cookie(tcp_ses);
1972
1973 /* queue echo request delayed work */
1974 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1975
1976 return tcp_ses;
1977
1978 out_err_crypto_release:
1979 cifs_crypto_shash_release(tcp_ses);
1980
1981 put_net(cifs_net_ns(tcp_ses));
1982
1983 out_err:
1984 if (tcp_ses) {
1985 if (!IS_ERR(tcp_ses->hostname))
1986 kfree(tcp_ses->hostname);
1987 if (tcp_ses->ssocket)
1988 sock_release(tcp_ses->ssocket);
1989 kfree(tcp_ses);
1990 }
1991 return ERR_PTR(rc);
1992 }
1993
1994 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
1995 {
1996 switch (ses->server->secType) {
1997 case Kerberos:
1998 if (vol->cred_uid != ses->cred_uid)
1999 return 0;
2000 break;
2001 default:
2002 /* NULL username means anonymous session */
2003 if (ses->user_name == NULL) {
2004 if (!vol->nullauth)
2005 return 0;
2006 break;
2007 }
2008
2009 /* anything else takes username/password */
2010 if (strncmp(ses->user_name,
2011 vol->username ? vol->username : "",
2012 MAX_USERNAME_SIZE))
2013 return 0;
2014 if (strlen(vol->username) != 0 &&
2015 ses->password != NULL &&
2016 strncmp(ses->password,
2017 vol->password ? vol->password : "",
2018 MAX_PASSWORD_SIZE))
2019 return 0;
2020 }
2021 return 1;
2022 }
2023
2024 static struct cifs_ses *
2025 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2026 {
2027 struct cifs_ses *ses;
2028
2029 spin_lock(&cifs_tcp_ses_lock);
2030 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2031 if (!match_session(ses, vol))
2032 continue;
2033 ++ses->ses_count;
2034 spin_unlock(&cifs_tcp_ses_lock);
2035 return ses;
2036 }
2037 spin_unlock(&cifs_tcp_ses_lock);
2038 return NULL;
2039 }
2040
2041 static void
2042 cifs_put_smb_ses(struct cifs_ses *ses)
2043 {
2044 int xid;
2045 struct TCP_Server_Info *server = ses->server;
2046
2047 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
2048 spin_lock(&cifs_tcp_ses_lock);
2049 if (--ses->ses_count > 0) {
2050 spin_unlock(&cifs_tcp_ses_lock);
2051 return;
2052 }
2053
2054 list_del_init(&ses->smb_ses_list);
2055 spin_unlock(&cifs_tcp_ses_lock);
2056
2057 if (ses->status == CifsGood) {
2058 xid = GetXid();
2059 CIFSSMBLogoff(xid, ses);
2060 _FreeXid(xid);
2061 }
2062 sesInfoFree(ses);
2063 cifs_put_tcp_session(server);
2064 }
2065
2066 #ifdef CONFIG_KEYS
2067
2068 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2069 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2070
2071 /* Populate username and pw fields from keyring if possible */
2072 static int
2073 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2074 {
2075 int rc = 0;
2076 char *desc, *delim, *payload;
2077 ssize_t len;
2078 struct key *key;
2079 struct TCP_Server_Info *server = ses->server;
2080 struct sockaddr_in *sa;
2081 struct sockaddr_in6 *sa6;
2082 struct user_key_payload *upayload;
2083
2084 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2085 if (!desc)
2086 return -ENOMEM;
2087
2088 /* try to find an address key first */
2089 switch (server->dstaddr.ss_family) {
2090 case AF_INET:
2091 sa = (struct sockaddr_in *)&server->dstaddr;
2092 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2093 break;
2094 case AF_INET6:
2095 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2096 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2097 break;
2098 default:
2099 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2100 rc = -EINVAL;
2101 goto out_err;
2102 }
2103
2104 cFYI(1, "%s: desc=%s", __func__, desc);
2105 key = request_key(&key_type_logon, desc, "");
2106 if (IS_ERR(key)) {
2107 if (!ses->domainName) {
2108 cFYI(1, "domainName is NULL");
2109 rc = PTR_ERR(key);
2110 goto out_err;
2111 }
2112
2113 /* didn't work, try to find a domain key */
2114 sprintf(desc, "cifs:d:%s", ses->domainName);
2115 cFYI(1, "%s: desc=%s", __func__, desc);
2116 key = request_key(&key_type_logon, desc, "");
2117 if (IS_ERR(key)) {
2118 rc = PTR_ERR(key);
2119 goto out_err;
2120 }
2121 }
2122
2123 down_read(&key->sem);
2124 upayload = key->payload.data;
2125 if (IS_ERR_OR_NULL(upayload)) {
2126 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2127 goto out_key_put;
2128 }
2129
2130 /* find first : in payload */
2131 payload = (char *)upayload->data;
2132 delim = strnchr(payload, upayload->datalen, ':');
2133 cFYI(1, "payload=%s", payload);
2134 if (!delim) {
2135 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2136 upayload->datalen);
2137 rc = -EINVAL;
2138 goto out_key_put;
2139 }
2140
2141 len = delim - payload;
2142 if (len > MAX_USERNAME_SIZE || len <= 0) {
2143 cFYI(1, "Bad value from username search (len=%zd)", len);
2144 rc = -EINVAL;
2145 goto out_key_put;
2146 }
2147
2148 vol->username = kstrndup(payload, len, GFP_KERNEL);
2149 if (!vol->username) {
2150 cFYI(1, "Unable to allocate %zd bytes for username", len);
2151 rc = -ENOMEM;
2152 goto out_key_put;
2153 }
2154 cFYI(1, "%s: username=%s", __func__, vol->username);
2155
2156 len = key->datalen - (len + 1);
2157 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2158 cFYI(1, "Bad len for password search (len=%zd)", len);
2159 rc = -EINVAL;
2160 kfree(vol->username);
2161 vol->username = NULL;
2162 goto out_key_put;
2163 }
2164
2165 ++delim;
2166 vol->password = kstrndup(delim, len, GFP_KERNEL);
2167 if (!vol->password) {
2168 cFYI(1, "Unable to allocate %zd bytes for password", len);
2169 rc = -ENOMEM;
2170 kfree(vol->username);
2171 vol->username = NULL;
2172 goto out_key_put;
2173 }
2174
2175 out_key_put:
2176 up_read(&key->sem);
2177 key_put(key);
2178 out_err:
2179 kfree(desc);
2180 cFYI(1, "%s: returning %d", __func__, rc);
2181 return rc;
2182 }
2183 #else /* ! CONFIG_KEYS */
2184 static inline int
2185 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2186 struct cifs_ses *ses __attribute__((unused)))
2187 {
2188 return -ENOSYS;
2189 }
2190 #endif /* CONFIG_KEYS */
2191
2192 static bool warned_on_ntlm; /* globals init to false automatically */
2193
2194 static struct cifs_ses *
2195 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2196 {
2197 int rc = -ENOMEM, xid;
2198 struct cifs_ses *ses;
2199 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2200 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2201
2202 xid = GetXid();
2203
2204 ses = cifs_find_smb_ses(server, volume_info);
2205 if (ses) {
2206 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2207
2208 mutex_lock(&ses->session_mutex);
2209 rc = cifs_negotiate_protocol(xid, ses);
2210 if (rc) {
2211 mutex_unlock(&ses->session_mutex);
2212 /* problem -- put our ses reference */
2213 cifs_put_smb_ses(ses);
2214 FreeXid(xid);
2215 return ERR_PTR(rc);
2216 }
2217 if (ses->need_reconnect) {
2218 cFYI(1, "Session needs reconnect");
2219 rc = cifs_setup_session(xid, ses,
2220 volume_info->local_nls);
2221 if (rc) {
2222 mutex_unlock(&ses->session_mutex);
2223 /* problem -- put our reference */
2224 cifs_put_smb_ses(ses);
2225 FreeXid(xid);
2226 return ERR_PTR(rc);
2227 }
2228 }
2229 mutex_unlock(&ses->session_mutex);
2230
2231 /* existing SMB ses has a server reference already */
2232 cifs_put_tcp_session(server);
2233 FreeXid(xid);
2234 return ses;
2235 }
2236
2237 cFYI(1, "Existing smb sess not found");
2238 ses = sesInfoAlloc();
2239 if (ses == NULL)
2240 goto get_ses_fail;
2241
2242 /* new SMB session uses our server ref */
2243 ses->server = server;
2244 if (server->dstaddr.ss_family == AF_INET6)
2245 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2246 else
2247 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2248
2249 if (volume_info->username) {
2250 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2251 if (!ses->user_name)
2252 goto get_ses_fail;
2253 }
2254
2255 /* volume_info->password freed at unmount */
2256 if (volume_info->password) {
2257 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2258 if (!ses->password)
2259 goto get_ses_fail;
2260 }
2261 if (volume_info->domainname) {
2262 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2263 if (!ses->domainName)
2264 goto get_ses_fail;
2265 }
2266 ses->cred_uid = volume_info->cred_uid;
2267 ses->linux_uid = volume_info->linux_uid;
2268
2269 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2270 supported for many years, time to update default security mechanism */
2271 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2272 warned_on_ntlm = true;
2273 cERROR(1, "default security mechanism requested. The default "
2274 "security mechanism will be upgraded from ntlm to "
2275 "ntlmv2 in kernel release 3.3");
2276 }
2277 ses->overrideSecFlg = volume_info->secFlg;
2278
2279 mutex_lock(&ses->session_mutex);
2280 rc = cifs_negotiate_protocol(xid, ses);
2281 if (!rc)
2282 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2283 mutex_unlock(&ses->session_mutex);
2284 if (rc)
2285 goto get_ses_fail;
2286
2287 /* success, put it on the list */
2288 spin_lock(&cifs_tcp_ses_lock);
2289 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2290 spin_unlock(&cifs_tcp_ses_lock);
2291
2292 FreeXid(xid);
2293 return ses;
2294
2295 get_ses_fail:
2296 sesInfoFree(ses);
2297 FreeXid(xid);
2298 return ERR_PTR(rc);
2299 }
2300
2301 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2302 {
2303 if (tcon->tidStatus == CifsExiting)
2304 return 0;
2305 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2306 return 0;
2307 return 1;
2308 }
2309
2310 static struct cifs_tcon *
2311 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2312 {
2313 struct list_head *tmp;
2314 struct cifs_tcon *tcon;
2315
2316 spin_lock(&cifs_tcp_ses_lock);
2317 list_for_each(tmp, &ses->tcon_list) {
2318 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2319 if (!match_tcon(tcon, unc))
2320 continue;
2321 ++tcon->tc_count;
2322 spin_unlock(&cifs_tcp_ses_lock);
2323 return tcon;
2324 }
2325 spin_unlock(&cifs_tcp_ses_lock);
2326 return NULL;
2327 }
2328
2329 static void
2330 cifs_put_tcon(struct cifs_tcon *tcon)
2331 {
2332 int xid;
2333 struct cifs_ses *ses = tcon->ses;
2334
2335 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2336 spin_lock(&cifs_tcp_ses_lock);
2337 if (--tcon->tc_count > 0) {
2338 spin_unlock(&cifs_tcp_ses_lock);
2339 return;
2340 }
2341
2342 list_del_init(&tcon->tcon_list);
2343 spin_unlock(&cifs_tcp_ses_lock);
2344
2345 xid = GetXid();
2346 CIFSSMBTDis(xid, tcon);
2347 _FreeXid(xid);
2348
2349 cifs_fscache_release_super_cookie(tcon);
2350 tconInfoFree(tcon);
2351 cifs_put_smb_ses(ses);
2352 }
2353
2354 static struct cifs_tcon *
2355 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2356 {
2357 int rc, xid;
2358 struct cifs_tcon *tcon;
2359
2360 tcon = cifs_find_tcon(ses, volume_info->UNC);
2361 if (tcon) {
2362 cFYI(1, "Found match on UNC path");
2363 /* existing tcon already has a reference */
2364 cifs_put_smb_ses(ses);
2365 if (tcon->seal != volume_info->seal)
2366 cERROR(1, "transport encryption setting "
2367 "conflicts with existing tid");
2368 return tcon;
2369 }
2370
2371 tcon = tconInfoAlloc();
2372 if (tcon == NULL) {
2373 rc = -ENOMEM;
2374 goto out_fail;
2375 }
2376
2377 tcon->ses = ses;
2378 if (volume_info->password) {
2379 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2380 if (!tcon->password) {
2381 rc = -ENOMEM;
2382 goto out_fail;
2383 }
2384 }
2385
2386 if (strchr(volume_info->UNC + 3, '\\') == NULL
2387 && strchr(volume_info->UNC + 3, '/') == NULL) {
2388 cERROR(1, "Missing share name");
2389 rc = -ENODEV;
2390 goto out_fail;
2391 }
2392
2393 /* BB Do we need to wrap session_mutex around
2394 * this TCon call and Unix SetFS as
2395 * we do on SessSetup and reconnect? */
2396 xid = GetXid();
2397 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2398 FreeXid(xid);
2399 cFYI(1, "CIFS Tcon rc = %d", rc);
2400 if (rc)
2401 goto out_fail;
2402
2403 if (volume_info->nodfs) {
2404 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2405 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2406 }
2407 tcon->seal = volume_info->seal;
2408 /* we can have only one retry value for a connection
2409 to a share so for resources mounted more than once
2410 to the same server share the last value passed in
2411 for the retry flag is used */
2412 tcon->retry = volume_info->retry;
2413 tcon->nocase = volume_info->nocase;
2414 tcon->local_lease = volume_info->local_lease;
2415
2416 spin_lock(&cifs_tcp_ses_lock);
2417 list_add(&tcon->tcon_list, &ses->tcon_list);
2418 spin_unlock(&cifs_tcp_ses_lock);
2419
2420 cifs_fscache_get_super_cookie(tcon);
2421
2422 return tcon;
2423
2424 out_fail:
2425 tconInfoFree(tcon);
2426 return ERR_PTR(rc);
2427 }
2428
2429 void
2430 cifs_put_tlink(struct tcon_link *tlink)
2431 {
2432 if (!tlink || IS_ERR(tlink))
2433 return;
2434
2435 if (!atomic_dec_and_test(&tlink->tl_count) ||
2436 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2437 tlink->tl_time = jiffies;
2438 return;
2439 }
2440
2441 if (!IS_ERR(tlink_tcon(tlink)))
2442 cifs_put_tcon(tlink_tcon(tlink));
2443 kfree(tlink);
2444 return;
2445 }
2446
2447 static inline struct tcon_link *
2448 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2449 {
2450 return cifs_sb->master_tlink;
2451 }
2452
2453 static int
2454 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2455 {
2456 struct cifs_sb_info *old = CIFS_SB(sb);
2457 struct cifs_sb_info *new = mnt_data->cifs_sb;
2458
2459 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2460 return 0;
2461
2462 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2463 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2464 return 0;
2465
2466 /*
2467 * We want to share sb only if we don't specify an r/wsize or
2468 * specified r/wsize is greater than or equal to existing one.
2469 */
2470 if (new->wsize && new->wsize < old->wsize)
2471 return 0;
2472
2473 if (new->rsize && new->rsize < old->rsize)
2474 return 0;
2475
2476 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2477 return 0;
2478
2479 if (old->mnt_file_mode != new->mnt_file_mode ||
2480 old->mnt_dir_mode != new->mnt_dir_mode)
2481 return 0;
2482
2483 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2484 return 0;
2485
2486 if (old->actimeo != new->actimeo)
2487 return 0;
2488
2489 return 1;
2490 }
2491
2492 int
2493 cifs_match_super(struct super_block *sb, void *data)
2494 {
2495 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2496 struct smb_vol *volume_info;
2497 struct cifs_sb_info *cifs_sb;
2498 struct TCP_Server_Info *tcp_srv;
2499 struct cifs_ses *ses;
2500 struct cifs_tcon *tcon;
2501 struct tcon_link *tlink;
2502 struct sockaddr_storage addr;
2503 int rc = 0;
2504
2505 memset(&addr, 0, sizeof(struct sockaddr_storage));
2506
2507 spin_lock(&cifs_tcp_ses_lock);
2508 cifs_sb = CIFS_SB(sb);
2509 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2510 if (IS_ERR(tlink)) {
2511 spin_unlock(&cifs_tcp_ses_lock);
2512 return rc;
2513 }
2514 tcon = tlink_tcon(tlink);
2515 ses = tcon->ses;
2516 tcp_srv = ses->server;
2517
2518 volume_info = mnt_data->vol;
2519
2520 if (!volume_info->UNCip || !volume_info->UNC)
2521 goto out;
2522
2523 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2524 volume_info->UNCip,
2525 strlen(volume_info->UNCip),
2526 volume_info->port);
2527 if (!rc)
2528 goto out;
2529
2530 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2531 !match_session(ses, volume_info) ||
2532 !match_tcon(tcon, volume_info->UNC)) {
2533 rc = 0;
2534 goto out;
2535 }
2536
2537 rc = compare_mount_options(sb, mnt_data);
2538 out:
2539 spin_unlock(&cifs_tcp_ses_lock);
2540 cifs_put_tlink(tlink);
2541 return rc;
2542 }
2543
2544 int
2545 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2546 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2547 struct dfs_info3_param **preferrals, int remap)
2548 {
2549 char *temp_unc;
2550 int rc = 0;
2551
2552 *pnum_referrals = 0;
2553 *preferrals = NULL;
2554
2555 if (pSesInfo->ipc_tid == 0) {
2556 temp_unc = kmalloc(2 /* for slashes */ +
2557 strnlen(pSesInfo->serverName,
2558 SERVER_NAME_LEN_WITH_NULL * 2)
2559 + 1 + 4 /* slash IPC$ */ + 2,
2560 GFP_KERNEL);
2561 if (temp_unc == NULL)
2562 return -ENOMEM;
2563 temp_unc[0] = '\\';
2564 temp_unc[1] = '\\';
2565 strcpy(temp_unc + 2, pSesInfo->serverName);
2566 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2567 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2568 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2569 kfree(temp_unc);
2570 }
2571 if (rc == 0)
2572 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2573 pnum_referrals, nls_codepage, remap);
2574 /* BB map targetUNCs to dfs_info3 structures, here or
2575 in CIFSGetDFSRefer BB */
2576
2577 return rc;
2578 }
2579
2580 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2581 static struct lock_class_key cifs_key[2];
2582 static struct lock_class_key cifs_slock_key[2];
2583
2584 static inline void
2585 cifs_reclassify_socket4(struct socket *sock)
2586 {
2587 struct sock *sk = sock->sk;
2588 BUG_ON(sock_owned_by_user(sk));
2589 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2590 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2591 }
2592
2593 static inline void
2594 cifs_reclassify_socket6(struct socket *sock)
2595 {
2596 struct sock *sk = sock->sk;
2597 BUG_ON(sock_owned_by_user(sk));
2598 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2599 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2600 }
2601 #else
2602 static inline void
2603 cifs_reclassify_socket4(struct socket *sock)
2604 {
2605 }
2606
2607 static inline void
2608 cifs_reclassify_socket6(struct socket *sock)
2609 {
2610 }
2611 #endif
2612
2613 /* See RFC1001 section 14 on representation of Netbios names */
2614 static void rfc1002mangle(char *target, char *source, unsigned int length)
2615 {
2616 unsigned int i, j;
2617
2618 for (i = 0, j = 0; i < (length); i++) {
2619 /* mask a nibble at a time and encode */
2620 target[j] = 'A' + (0x0F & (source[i] >> 4));
2621 target[j+1] = 'A' + (0x0F & source[i]);
2622 j += 2;
2623 }
2624
2625 }
2626
2627 static int
2628 bind_socket(struct TCP_Server_Info *server)
2629 {
2630 int rc = 0;
2631 if (server->srcaddr.ss_family != AF_UNSPEC) {
2632 /* Bind to the specified local IP address */
2633 struct socket *socket = server->ssocket;
2634 rc = socket->ops->bind(socket,
2635 (struct sockaddr *) &server->srcaddr,
2636 sizeof(server->srcaddr));
2637 if (rc < 0) {
2638 struct sockaddr_in *saddr4;
2639 struct sockaddr_in6 *saddr6;
2640 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2641 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2642 if (saddr6->sin6_family == AF_INET6)
2643 cERROR(1, "cifs: "
2644 "Failed to bind to: %pI6c, error: %d\n",
2645 &saddr6->sin6_addr, rc);
2646 else
2647 cERROR(1, "cifs: "
2648 "Failed to bind to: %pI4, error: %d\n",
2649 &saddr4->sin_addr.s_addr, rc);
2650 }
2651 }
2652 return rc;
2653 }
2654
2655 static int
2656 ip_rfc1001_connect(struct TCP_Server_Info *server)
2657 {
2658 int rc = 0;
2659 /*
2660 * some servers require RFC1001 sessinit before sending
2661 * negprot - BB check reconnection in case where second
2662 * sessinit is sent but no second negprot
2663 */
2664 struct rfc1002_session_packet *ses_init_buf;
2665 struct smb_hdr *smb_buf;
2666 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2667 GFP_KERNEL);
2668 if (ses_init_buf) {
2669 ses_init_buf->trailer.session_req.called_len = 32;
2670
2671 if (server->server_RFC1001_name &&
2672 server->server_RFC1001_name[0] != 0)
2673 rfc1002mangle(ses_init_buf->trailer.
2674 session_req.called_name,
2675 server->server_RFC1001_name,
2676 RFC1001_NAME_LEN_WITH_NULL);
2677 else
2678 rfc1002mangle(ses_init_buf->trailer.
2679 session_req.called_name,
2680 DEFAULT_CIFS_CALLED_NAME,
2681 RFC1001_NAME_LEN_WITH_NULL);
2682
2683 ses_init_buf->trailer.session_req.calling_len = 32;
2684
2685 /*
2686 * calling name ends in null (byte 16) from old smb
2687 * convention.
2688 */
2689 if (server->workstation_RFC1001_name &&
2690 server->workstation_RFC1001_name[0] != 0)
2691 rfc1002mangle(ses_init_buf->trailer.
2692 session_req.calling_name,
2693 server->workstation_RFC1001_name,
2694 RFC1001_NAME_LEN_WITH_NULL);
2695 else
2696 rfc1002mangle(ses_init_buf->trailer.
2697 session_req.calling_name,
2698 "LINUX_CIFS_CLNT",
2699 RFC1001_NAME_LEN_WITH_NULL);
2700
2701 ses_init_buf->trailer.session_req.scope1 = 0;
2702 ses_init_buf->trailer.session_req.scope2 = 0;
2703 smb_buf = (struct smb_hdr *)ses_init_buf;
2704
2705 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2706 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2707 rc = smb_send(server, smb_buf, 0x44);
2708 kfree(ses_init_buf);
2709 /*
2710 * RFC1001 layer in at least one server
2711 * requires very short break before negprot
2712 * presumably because not expecting negprot
2713 * to follow so fast. This is a simple
2714 * solution that works without
2715 * complicating the code and causes no
2716 * significant slowing down on mount
2717 * for everyone else
2718 */
2719 usleep_range(1000, 2000);
2720 }
2721 /*
2722 * else the negprot may still work without this
2723 * even though malloc failed
2724 */
2725
2726 return rc;
2727 }
2728
2729 static int
2730 generic_ip_connect(struct TCP_Server_Info *server)
2731 {
2732 int rc = 0;
2733 __be16 sport;
2734 int slen, sfamily;
2735 struct socket *socket = server->ssocket;
2736 struct sockaddr *saddr;
2737
2738 saddr = (struct sockaddr *) &server->dstaddr;
2739
2740 if (server->dstaddr.ss_family == AF_INET6) {
2741 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2742 slen = sizeof(struct sockaddr_in6);
2743 sfamily = AF_INET6;
2744 } else {
2745 sport = ((struct sockaddr_in *) saddr)->sin_port;
2746 slen = sizeof(struct sockaddr_in);
2747 sfamily = AF_INET;
2748 }
2749
2750 if (socket == NULL) {
2751 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2752 IPPROTO_TCP, &socket, 1);
2753 if (rc < 0) {
2754 cERROR(1, "Error %d creating socket", rc);
2755 server->ssocket = NULL;
2756 return rc;
2757 }
2758
2759 /* BB other socket options to set KEEPALIVE, NODELAY? */
2760 cFYI(1, "Socket created");
2761 server->ssocket = socket;
2762 socket->sk->sk_allocation = GFP_NOFS;
2763 if (sfamily == AF_INET6)
2764 cifs_reclassify_socket6(socket);
2765 else
2766 cifs_reclassify_socket4(socket);
2767 }
2768
2769 rc = bind_socket(server);
2770 if (rc < 0)
2771 return rc;
2772
2773 /*
2774 * Eventually check for other socket options to change from
2775 * the default. sock_setsockopt not used because it expects
2776 * user space buffer
2777 */
2778 socket->sk->sk_rcvtimeo = 7 * HZ;
2779 socket->sk->sk_sndtimeo = 5 * HZ;
2780
2781 /* make the bufsizes depend on wsize/rsize and max requests */
2782 if (server->noautotune) {
2783 if (socket->sk->sk_sndbuf < (200 * 1024))
2784 socket->sk->sk_sndbuf = 200 * 1024;
2785 if (socket->sk->sk_rcvbuf < (140 * 1024))
2786 socket->sk->sk_rcvbuf = 140 * 1024;
2787 }
2788
2789 if (server->tcp_nodelay) {
2790 int val = 1;
2791 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2792 (char *)&val, sizeof(val));
2793 if (rc)
2794 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2795 }
2796
2797 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2798 socket->sk->sk_sndbuf,
2799 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2800
2801 rc = socket->ops->connect(socket, saddr, slen, 0);
2802 if (rc < 0) {
2803 cFYI(1, "Error %d connecting to server", rc);
2804 sock_release(socket);
2805 server->ssocket = NULL;
2806 return rc;
2807 }
2808
2809 if (sport == htons(RFC1001_PORT))
2810 rc = ip_rfc1001_connect(server);
2811
2812 return rc;
2813 }
2814
2815 static int
2816 ip_connect(struct TCP_Server_Info *server)
2817 {
2818 __be16 *sport;
2819 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2820 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2821
2822 if (server->dstaddr.ss_family == AF_INET6)
2823 sport = &addr6->sin6_port;
2824 else
2825 sport = &addr->sin_port;
2826
2827 if (*sport == 0) {
2828 int rc;
2829
2830 /* try with 445 port at first */
2831 *sport = htons(CIFS_PORT);
2832
2833 rc = generic_ip_connect(server);
2834 if (rc >= 0)
2835 return rc;
2836
2837 /* if it failed, try with 139 port */
2838 *sport = htons(RFC1001_PORT);
2839 }
2840
2841 return generic_ip_connect(server);
2842 }
2843
2844 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
2845 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
2846 {
2847 /* if we are reconnecting then should we check to see if
2848 * any requested capabilities changed locally e.g. via
2849 * remount but we can not do much about it here
2850 * if they have (even if we could detect it by the following)
2851 * Perhaps we could add a backpointer to array of sb from tcon
2852 * or if we change to make all sb to same share the same
2853 * sb as NFS - then we only have one backpointer to sb.
2854 * What if we wanted to mount the server share twice once with
2855 * and once without posixacls or posix paths? */
2856 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2857
2858 if (vol_info && vol_info->no_linux_ext) {
2859 tcon->fsUnixInfo.Capability = 0;
2860 tcon->unix_ext = 0; /* Unix Extensions disabled */
2861 cFYI(1, "Linux protocol extensions disabled");
2862 return;
2863 } else if (vol_info)
2864 tcon->unix_ext = 1; /* Unix Extensions supported */
2865
2866 if (tcon->unix_ext == 0) {
2867 cFYI(1, "Unix extensions disabled so not set on reconnect");
2868 return;
2869 }
2870
2871 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2872 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2873 cFYI(1, "unix caps which server supports %lld", cap);
2874 /* check for reconnect case in which we do not
2875 want to change the mount behavior if we can avoid it */
2876 if (vol_info == NULL) {
2877 /* turn off POSIX ACL and PATHNAMES if not set
2878 originally at mount time */
2879 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2880 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2881 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2882 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2883 cERROR(1, "POSIXPATH support change");
2884 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2885 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2886 cERROR(1, "possible reconnect error");
2887 cERROR(1, "server disabled POSIX path support");
2888 }
2889 }
2890
2891 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2892 cERROR(1, "per-share encryption not supported yet");
2893
2894 cap &= CIFS_UNIX_CAP_MASK;
2895 if (vol_info && vol_info->no_psx_acl)
2896 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2897 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2898 cFYI(1, "negotiated posix acl support");
2899 if (cifs_sb)
2900 cifs_sb->mnt_cifs_flags |=
2901 CIFS_MOUNT_POSIXACL;
2902 }
2903
2904 if (vol_info && vol_info->posix_paths == 0)
2905 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2906 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2907 cFYI(1, "negotiate posix pathnames");
2908 if (cifs_sb)
2909 cifs_sb->mnt_cifs_flags |=
2910 CIFS_MOUNT_POSIX_PATHS;
2911 }
2912
2913 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2914 #ifdef CONFIG_CIFS_DEBUG2
2915 if (cap & CIFS_UNIX_FCNTL_CAP)
2916 cFYI(1, "FCNTL cap");
2917 if (cap & CIFS_UNIX_EXTATTR_CAP)
2918 cFYI(1, "EXTATTR cap");
2919 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2920 cFYI(1, "POSIX path cap");
2921 if (cap & CIFS_UNIX_XATTR_CAP)
2922 cFYI(1, "XATTR cap");
2923 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2924 cFYI(1, "POSIX ACL cap");
2925 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2926 cFYI(1, "very large read cap");
2927 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2928 cFYI(1, "very large write cap");
2929 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2930 cFYI(1, "transport encryption cap");
2931 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2932 cFYI(1, "mandatory transport encryption cap");
2933 #endif /* CIFS_DEBUG2 */
2934 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2935 if (vol_info == NULL) {
2936 cFYI(1, "resetting capabilities failed");
2937 } else
2938 cERROR(1, "Negotiating Unix capabilities "
2939 "with the server failed. Consider "
2940 "mounting with the Unix Extensions\n"
2941 "disabled, if problems are found, "
2942 "by specifying the nounix mount "
2943 "option.");
2944
2945 }
2946 }
2947 }
2948
2949 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
2950 struct cifs_sb_info *cifs_sb)
2951 {
2952 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2953
2954 spin_lock_init(&cifs_sb->tlink_tree_lock);
2955 cifs_sb->tlink_tree = RB_ROOT;
2956
2957 /*
2958 * Temporarily set r/wsize for matching superblock. If we end up using
2959 * new sb then client will later negotiate it downward if needed.
2960 */
2961 cifs_sb->rsize = pvolume_info->rsize;
2962 cifs_sb->wsize = pvolume_info->wsize;
2963
2964 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2965 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2966 if (pvolume_info->backupuid_specified)
2967 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
2968 if (pvolume_info->backupgid_specified)
2969 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
2970 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2971 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2972 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
2973 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2974
2975 cifs_sb->actimeo = pvolume_info->actimeo;
2976 cifs_sb->local_nls = pvolume_info->local_nls;
2977
2978 if (pvolume_info->noperm)
2979 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2980 if (pvolume_info->setuids)
2981 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2982 if (pvolume_info->server_ino)
2983 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2984 if (pvolume_info->remap)
2985 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2986 if (pvolume_info->no_xattr)
2987 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2988 if (pvolume_info->sfu_emul)
2989 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2990 if (pvolume_info->nobrl)
2991 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2992 if (pvolume_info->nostrictsync)
2993 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2994 if (pvolume_info->mand_lock)
2995 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2996 if (pvolume_info->rwpidforward)
2997 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2998 if (pvolume_info->cifs_acl)
2999 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3000 if (pvolume_info->backupuid_specified)
3001 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3002 if (pvolume_info->backupgid_specified)
3003 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3004 if (pvolume_info->override_uid)
3005 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3006 if (pvolume_info->override_gid)
3007 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3008 if (pvolume_info->dynperm)
3009 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3010 if (pvolume_info->fsc)
3011 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3012 if (pvolume_info->multiuser)
3013 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3014 CIFS_MOUNT_NO_PERM);
3015 if (pvolume_info->strict_io)
3016 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3017 if (pvolume_info->direct_io) {
3018 cFYI(1, "mounting share using direct i/o");
3019 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3020 }
3021 if (pvolume_info->mfsymlinks) {
3022 if (pvolume_info->sfu_emul) {
3023 cERROR(1, "mount option mfsymlinks ignored if sfu "
3024 "mount option is used");
3025 } else {
3026 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3027 }
3028 }
3029
3030 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3031 cERROR(1, "mount option dynperm ignored if cifsacl "
3032 "mount option supported");
3033 }
3034
3035 /*
3036 * When the server supports very large reads and writes via POSIX extensions,
3037 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3038 * including the RFC1001 length.
3039 *
3040 * Note that this might make for "interesting" allocation problems during
3041 * writeback however as we have to allocate an array of pointers for the
3042 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3043 *
3044 * For reads, there is a similar problem as we need to allocate an array
3045 * of kvecs to handle the receive, though that should only need to be done
3046 * once.
3047 */
3048 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3049 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3050
3051 /*
3052 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3053 * of 2^17-1 minus the size of the call header. That allows for a read or
3054 * write up to the maximum size described by RFC1002.
3055 */
3056 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3057 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3058
3059 /*
3060 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3061 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3062 * a single wsize request with a single call.
3063 */
3064 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3065
3066 /*
3067 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3068 * those values when posix extensions aren't in force. In actuality here, we
3069 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3070 * to be ok with the extra byte even though Windows doesn't send writes that
3071 * are that large.
3072 *
3073 * Citation:
3074 *
3075 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3076 */
3077 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3078 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3079
3080 static unsigned int
3081 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3082 {
3083 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3084 struct TCP_Server_Info *server = tcon->ses->server;
3085 unsigned int wsize;
3086
3087 /* start with specified wsize, or default */
3088 if (pvolume_info->wsize)
3089 wsize = pvolume_info->wsize;
3090 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3091 wsize = CIFS_DEFAULT_IOSIZE;
3092 else
3093 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3094
3095 /* can server support 24-bit write sizes? (via UNIX extensions) */
3096 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3097 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3098
3099 /*
3100 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3101 * Limit it to max buffer offered by the server, minus the size of the
3102 * WRITEX header, not including the 4 byte RFC1001 length.
3103 */
3104 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3105 (!(server->capabilities & CAP_UNIX) &&
3106 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3107 wsize = min_t(unsigned int, wsize,
3108 server->maxBuf - sizeof(WRITE_REQ) + 4);
3109
3110 /* hard limit of CIFS_MAX_WSIZE */
3111 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3112
3113 return wsize;
3114 }
3115
3116 static unsigned int
3117 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3118 {
3119 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3120 struct TCP_Server_Info *server = tcon->ses->server;
3121 unsigned int rsize, defsize;
3122
3123 /*
3124 * Set default value...
3125 *
3126 * HACK alert! Ancient servers have very small buffers. Even though
3127 * MS-CIFS indicates that servers are only limited by the client's
3128 * bufsize for reads, testing against win98se shows that it throws
3129 * INVALID_PARAMETER errors if you try to request too large a read.
3130 *
3131 * If the server advertises a MaxBufferSize of less than one page,
3132 * assume that it also can't satisfy reads larger than that either.
3133 *
3134 * FIXME: Is there a better heuristic for this?
3135 */
3136 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3137 defsize = CIFS_DEFAULT_IOSIZE;
3138 else if (server->capabilities & CAP_LARGE_READ_X)
3139 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3140 else if (server->maxBuf >= PAGE_CACHE_SIZE)
3141 defsize = CIFSMaxBufSize;
3142 else
3143 defsize = server->maxBuf - sizeof(READ_RSP);
3144
3145 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3146
3147 /*
3148 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3149 * the client's MaxBufferSize.
3150 */
3151 if (!(server->capabilities & CAP_LARGE_READ_X))
3152 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3153
3154 /* hard limit of CIFS_MAX_RSIZE */
3155 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3156
3157 return rsize;
3158 }
3159
3160 static int
3161 is_path_accessible(int xid, struct cifs_tcon *tcon,
3162 struct cifs_sb_info *cifs_sb, const char *full_path)
3163 {
3164 int rc;
3165 FILE_ALL_INFO *pfile_info;
3166
3167 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3168 if (pfile_info == NULL)
3169 return -ENOMEM;
3170
3171 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3172 0 /* not legacy */, cifs_sb->local_nls,
3173 cifs_sb->mnt_cifs_flags &
3174 CIFS_MOUNT_MAP_SPECIAL_CHR);
3175
3176 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3177 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3178 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3179 CIFS_MOUNT_MAP_SPECIAL_CHR);
3180 kfree(pfile_info);
3181 return rc;
3182 }
3183
3184 static void
3185 cleanup_volume_info_contents(struct smb_vol *volume_info)
3186 {
3187 kfree(volume_info->username);
3188 kzfree(volume_info->password);
3189 if (volume_info->UNCip != volume_info->UNC + 2)
3190 kfree(volume_info->UNCip);
3191 kfree(volume_info->UNC);
3192 kfree(volume_info->domainname);
3193 kfree(volume_info->iocharset);
3194 kfree(volume_info->prepath);
3195 }
3196
3197 void
3198 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3199 {
3200 if (!volume_info)
3201 return;
3202 cleanup_volume_info_contents(volume_info);
3203 kfree(volume_info);
3204 }
3205
3206
3207 #ifdef CONFIG_CIFS_DFS_UPCALL
3208 /* build_path_to_root returns full path to root when
3209 * we do not have an exiting connection (tcon) */
3210 static char *
3211 build_unc_path_to_root(const struct smb_vol *vol,
3212 const struct cifs_sb_info *cifs_sb)
3213 {
3214 char *full_path, *pos;
3215 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3216 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3217
3218 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3219 if (full_path == NULL)
3220 return ERR_PTR(-ENOMEM);
3221
3222 strncpy(full_path, vol->UNC, unc_len);
3223 pos = full_path + unc_len;
3224
3225 if (pplen) {
3226 strncpy(pos, vol->prepath, pplen);
3227 pos += pplen;
3228 }
3229
3230 *pos = '\0'; /* add trailing null */
3231 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3232 cFYI(1, "%s: full_path=%s", __func__, full_path);
3233 return full_path;
3234 }
3235
3236 /*
3237 * Perform a dfs referral query for a share and (optionally) prefix
3238 *
3239 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3240 * to a string containing updated options for the submount. Otherwise it
3241 * will be left untouched.
3242 *
3243 * Returns the rc from get_dfs_path to the caller, which can be used to
3244 * determine whether there were referrals.
3245 */
3246 static int
3247 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3248 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3249 int check_prefix)
3250 {
3251 int rc;
3252 unsigned int num_referrals = 0;
3253 struct dfs_info3_param *referrals = NULL;
3254 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3255
3256 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3257 if (IS_ERR(full_path))
3258 return PTR_ERR(full_path);
3259
3260 /* For DFS paths, skip the first '\' of the UNC */
3261 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3262
3263 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3264 &num_referrals, &referrals,
3265 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3266
3267 if (!rc && num_referrals > 0) {
3268 char *fake_devname = NULL;
3269
3270 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3271 full_path + 1, referrals,
3272 &fake_devname);
3273
3274 free_dfs_info_array(referrals, num_referrals);
3275
3276 if (IS_ERR(mdata)) {
3277 rc = PTR_ERR(mdata);
3278 mdata = NULL;
3279 } else {
3280 cleanup_volume_info_contents(volume_info);
3281 memset(volume_info, '\0', sizeof(*volume_info));
3282 rc = cifs_setup_volume_info(volume_info, mdata,
3283 fake_devname);
3284 }
3285 kfree(fake_devname);
3286 kfree(cifs_sb->mountdata);
3287 cifs_sb->mountdata = mdata;
3288 }
3289 kfree(full_path);
3290 return rc;
3291 }
3292 #endif
3293
3294 static int
3295 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3296 const char *devname)
3297 {
3298 int rc = 0;
3299
3300 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3301 return -EINVAL;
3302
3303 if (volume_info->nullauth) {
3304 cFYI(1, "Anonymous login");
3305 kfree(volume_info->username);
3306 volume_info->username = NULL;
3307 } else if (volume_info->username) {
3308 /* BB fixme parse for domain name here */
3309 cFYI(1, "Username: %s", volume_info->username);
3310 } else {
3311 cifserror("No username specified");
3312 /* In userspace mount helper we can get user name from alternate
3313 locations such as env variables and files on disk */
3314 return -EINVAL;
3315 }
3316
3317 /* this is needed for ASCII cp to Unicode converts */
3318 if (volume_info->iocharset == NULL) {
3319 /* load_nls_default cannot return null */
3320 volume_info->local_nls = load_nls_default();
3321 } else {
3322 volume_info->local_nls = load_nls(volume_info->iocharset);
3323 if (volume_info->local_nls == NULL) {
3324 cERROR(1, "CIFS mount error: iocharset %s not found",
3325 volume_info->iocharset);
3326 return -ELIBACC;
3327 }
3328 }
3329
3330 return rc;
3331 }
3332
3333 struct smb_vol *
3334 cifs_get_volume_info(char *mount_data, const char *devname)
3335 {
3336 int rc;
3337 struct smb_vol *volume_info;
3338
3339 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3340 if (!volume_info)
3341 return ERR_PTR(-ENOMEM);
3342
3343 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3344 if (rc) {
3345 cifs_cleanup_volume_info(volume_info);
3346 volume_info = ERR_PTR(rc);
3347 }
3348
3349 return volume_info;
3350 }
3351
3352 /* make sure ra_pages is a multiple of rsize */
3353 static inline unsigned int
3354 cifs_ra_pages(struct cifs_sb_info *cifs_sb)
3355 {
3356 unsigned int reads;
3357 unsigned int rsize_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3358
3359 if (rsize_pages >= default_backing_dev_info.ra_pages)
3360 return default_backing_dev_info.ra_pages;
3361 else if (rsize_pages == 0)
3362 return rsize_pages;
3363
3364 reads = default_backing_dev_info.ra_pages / rsize_pages;
3365 return reads * rsize_pages;
3366 }
3367
3368 int
3369 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3370 {
3371 int rc;
3372 int xid;
3373 struct cifs_ses *pSesInfo;
3374 struct cifs_tcon *tcon;
3375 struct TCP_Server_Info *srvTcp;
3376 char *full_path;
3377 struct tcon_link *tlink;
3378 #ifdef CONFIG_CIFS_DFS_UPCALL
3379 int referral_walks_count = 0;
3380 #endif
3381
3382 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3383 if (rc)
3384 return rc;
3385
3386 #ifdef CONFIG_CIFS_DFS_UPCALL
3387 try_mount_again:
3388 /* cleanup activities if we're chasing a referral */
3389 if (referral_walks_count) {
3390 if (tcon)
3391 cifs_put_tcon(tcon);
3392 else if (pSesInfo)
3393 cifs_put_smb_ses(pSesInfo);
3394
3395 FreeXid(xid);
3396 }
3397 #endif
3398 rc = 0;
3399 tcon = NULL;
3400 pSesInfo = NULL;
3401 srvTcp = NULL;
3402 full_path = NULL;
3403 tlink = NULL;
3404
3405 xid = GetXid();
3406
3407 /* get a reference to a tcp session */
3408 srvTcp = cifs_get_tcp_session(volume_info);
3409 if (IS_ERR(srvTcp)) {
3410 rc = PTR_ERR(srvTcp);
3411 bdi_destroy(&cifs_sb->bdi);
3412 goto out;
3413 }
3414
3415 /* get a reference to a SMB session */
3416 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3417 if (IS_ERR(pSesInfo)) {
3418 rc = PTR_ERR(pSesInfo);
3419 pSesInfo = NULL;
3420 goto mount_fail_check;
3421 }
3422
3423 /* search for existing tcon to this server share */
3424 tcon = cifs_get_tcon(pSesInfo, volume_info);
3425 if (IS_ERR(tcon)) {
3426 rc = PTR_ERR(tcon);
3427 tcon = NULL;
3428 goto remote_path_check;
3429 }
3430
3431 /* tell server which Unix caps we support */
3432 if (tcon->ses->capabilities & CAP_UNIX) {
3433 /* reset of caps checks mount to see if unix extensions
3434 disabled for just this mount */
3435 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3436 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3437 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3438 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3439 rc = -EACCES;
3440 goto mount_fail_check;
3441 }
3442 } else
3443 tcon->unix_ext = 0; /* server does not support them */
3444
3445 /* do not care if following two calls succeed - informational */
3446 if (!tcon->ipc) {
3447 CIFSSMBQFSDeviceInfo(xid, tcon);
3448 CIFSSMBQFSAttributeInfo(xid, tcon);
3449 }
3450
3451 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3452 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3453
3454 /* tune readahead according to rsize */
3455 cifs_sb->bdi.ra_pages = cifs_ra_pages(cifs_sb);
3456
3457 remote_path_check:
3458 #ifdef CONFIG_CIFS_DFS_UPCALL
3459 /*
3460 * Perform an unconditional check for whether there are DFS
3461 * referrals for this path without prefix, to provide support
3462 * for DFS referrals from w2k8 servers which don't seem to respond
3463 * with PATH_NOT_COVERED to requests that include the prefix.
3464 * Chase the referral if found, otherwise continue normally.
3465 */
3466 if (referral_walks_count == 0) {
3467 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3468 cifs_sb, false);
3469 if (!refrc) {
3470 referral_walks_count++;
3471 goto try_mount_again;
3472 }
3473 }
3474 #endif
3475
3476 /* check if a whole path is not remote */
3477 if (!rc && tcon) {
3478 /* build_path_to_root works only when we have a valid tcon */
3479 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3480 if (full_path == NULL) {
3481 rc = -ENOMEM;
3482 goto mount_fail_check;
3483 }
3484 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3485 if (rc != 0 && rc != -EREMOTE) {
3486 kfree(full_path);
3487 goto mount_fail_check;
3488 }
3489 kfree(full_path);
3490 }
3491
3492 /* get referral if needed */
3493 if (rc == -EREMOTE) {
3494 #ifdef CONFIG_CIFS_DFS_UPCALL
3495 if (referral_walks_count > MAX_NESTED_LINKS) {
3496 /*
3497 * BB: when we implement proper loop detection,
3498 * we will remove this check. But now we need it
3499 * to prevent an indefinite loop if 'DFS tree' is
3500 * misconfigured (i.e. has loops).
3501 */
3502 rc = -ELOOP;
3503 goto mount_fail_check;
3504 }
3505
3506 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3507 true);
3508
3509 if (!rc) {
3510 referral_walks_count++;
3511 goto try_mount_again;
3512 }
3513 goto mount_fail_check;
3514 #else /* No DFS support, return error on mount */
3515 rc = -EOPNOTSUPP;
3516 #endif
3517 }
3518
3519 if (rc)
3520 goto mount_fail_check;
3521
3522 /* now, hang the tcon off of the superblock */
3523 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3524 if (tlink == NULL) {
3525 rc = -ENOMEM;
3526 goto mount_fail_check;
3527 }
3528
3529 tlink->tl_uid = pSesInfo->linux_uid;
3530 tlink->tl_tcon = tcon;
3531 tlink->tl_time = jiffies;
3532 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3533 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3534
3535 cifs_sb->master_tlink = tlink;
3536 spin_lock(&cifs_sb->tlink_tree_lock);
3537 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3538 spin_unlock(&cifs_sb->tlink_tree_lock);
3539
3540 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3541 TLINK_IDLE_EXPIRE);
3542
3543 mount_fail_check:
3544 /* on error free sesinfo and tcon struct if needed */
3545 if (rc) {
3546 /* If find_unc succeeded then rc == 0 so we can not end */
3547 /* up accidentally freeing someone elses tcon struct */
3548 if (tcon)
3549 cifs_put_tcon(tcon);
3550 else if (pSesInfo)
3551 cifs_put_smb_ses(pSesInfo);
3552 else
3553 cifs_put_tcp_session(srvTcp);
3554 bdi_destroy(&cifs_sb->bdi);
3555 }
3556
3557 out:
3558 FreeXid(xid);
3559 return rc;
3560 }
3561
3562 /*
3563 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3564 * pointer may be NULL.
3565 */
3566 int
3567 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3568 const char *tree, struct cifs_tcon *tcon,
3569 const struct nls_table *nls_codepage)
3570 {
3571 struct smb_hdr *smb_buffer;
3572 struct smb_hdr *smb_buffer_response;
3573 TCONX_REQ *pSMB;
3574 TCONX_RSP *pSMBr;
3575 unsigned char *bcc_ptr;
3576 int rc = 0;
3577 int length;
3578 __u16 bytes_left, count;
3579
3580 if (ses == NULL)
3581 return -EIO;
3582
3583 smb_buffer = cifs_buf_get();
3584 if (smb_buffer == NULL)
3585 return -ENOMEM;
3586
3587 smb_buffer_response = smb_buffer;
3588
3589 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3590 NULL /*no tid */ , 4 /*wct */ );
3591
3592 smb_buffer->Mid = GetNextMid(ses->server);
3593 smb_buffer->Uid = ses->Suid;
3594 pSMB = (TCONX_REQ *) smb_buffer;
3595 pSMBr = (TCONX_RSP *) smb_buffer_response;
3596
3597 pSMB->AndXCommand = 0xFF;
3598 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3599 bcc_ptr = &pSMB->Password[0];
3600 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3601 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3602 *bcc_ptr = 0; /* password is null byte */
3603 bcc_ptr++; /* skip password */
3604 /* already aligned so no need to do it below */
3605 } else {
3606 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3607 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3608 specified as required (when that support is added to
3609 the vfs in the future) as only NTLM or the much
3610 weaker LANMAN (which we do not send by default) is accepted
3611 by Samba (not sure whether other servers allow
3612 NTLMv2 password here) */
3613 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3614 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3615 (ses->server->secType == LANMAN))
3616 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3617 ses->server->sec_mode &
3618 SECMODE_PW_ENCRYPT ? true : false,
3619 bcc_ptr);
3620 else
3621 #endif /* CIFS_WEAK_PW_HASH */
3622 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3623 bcc_ptr, nls_codepage);
3624
3625 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3626 if (ses->capabilities & CAP_UNICODE) {
3627 /* must align unicode strings */
3628 *bcc_ptr = 0; /* null byte password */
3629 bcc_ptr++;
3630 }
3631 }
3632
3633 if (ses->server->sec_mode &
3634 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3635 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3636
3637 if (ses->capabilities & CAP_STATUS32) {
3638 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3639 }
3640 if (ses->capabilities & CAP_DFS) {
3641 smb_buffer->Flags2 |= SMBFLG2_DFS;
3642 }
3643 if (ses->capabilities & CAP_UNICODE) {
3644 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3645 length =
3646 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3647 6 /* max utf8 char length in bytes */ *
3648 (/* server len*/ + 256 /* share len */), nls_codepage);
3649 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3650 bcc_ptr += 2; /* skip trailing null */
3651 } else { /* ASCII */
3652 strcpy(bcc_ptr, tree);
3653 bcc_ptr += strlen(tree) + 1;
3654 }
3655 strcpy(bcc_ptr, "?????");
3656 bcc_ptr += strlen("?????");
3657 bcc_ptr += 1;
3658 count = bcc_ptr - &pSMB->Password[0];
3659 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3660 pSMB->hdr.smb_buf_length) + count);
3661 pSMB->ByteCount = cpu_to_le16(count);
3662
3663 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3664 0);
3665
3666 /* above now done in SendReceive */
3667 if ((rc == 0) && (tcon != NULL)) {
3668 bool is_unicode;
3669
3670 tcon->tidStatus = CifsGood;
3671 tcon->need_reconnect = false;
3672 tcon->tid = smb_buffer_response->Tid;
3673 bcc_ptr = pByteArea(smb_buffer_response);
3674 bytes_left = get_bcc(smb_buffer_response);
3675 length = strnlen(bcc_ptr, bytes_left - 2);
3676 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3677 is_unicode = true;
3678 else
3679 is_unicode = false;
3680
3681
3682 /* skip service field (NB: this field is always ASCII) */
3683 if (length == 3) {
3684 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3685 (bcc_ptr[2] == 'C')) {
3686 cFYI(1, "IPC connection");
3687 tcon->ipc = 1;
3688 }
3689 } else if (length == 2) {
3690 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3691 /* the most common case */
3692 cFYI(1, "disk share connection");
3693 }
3694 }
3695 bcc_ptr += length + 1;
3696 bytes_left -= (length + 1);
3697 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3698
3699 /* mostly informational -- no need to fail on error here */
3700 kfree(tcon->nativeFileSystem);
3701 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3702 bytes_left, is_unicode,
3703 nls_codepage);
3704
3705 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3706
3707 if ((smb_buffer_response->WordCount == 3) ||
3708 (smb_buffer_response->WordCount == 7))
3709 /* field is in same location */
3710 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3711 else
3712 tcon->Flags = 0;
3713 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3714 } else if ((rc == 0) && tcon == NULL) {
3715 /* all we need to save for IPC$ connection */
3716 ses->ipc_tid = smb_buffer_response->Tid;
3717 }
3718
3719 cifs_buf_release(smb_buffer);
3720 return rc;
3721 }
3722
3723 void
3724 cifs_umount(struct cifs_sb_info *cifs_sb)
3725 {
3726 struct rb_root *root = &cifs_sb->tlink_tree;
3727 struct rb_node *node;
3728 struct tcon_link *tlink;
3729
3730 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3731
3732 spin_lock(&cifs_sb->tlink_tree_lock);
3733 while ((node = rb_first(root))) {
3734 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3735 cifs_get_tlink(tlink);
3736 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3737 rb_erase(node, root);
3738
3739 spin_unlock(&cifs_sb->tlink_tree_lock);
3740 cifs_put_tlink(tlink);
3741 spin_lock(&cifs_sb->tlink_tree_lock);
3742 }
3743 spin_unlock(&cifs_sb->tlink_tree_lock);
3744
3745 bdi_destroy(&cifs_sb->bdi);
3746 kfree(cifs_sb->mountdata);
3747 unload_nls(cifs_sb->local_nls);
3748 kfree(cifs_sb);
3749 }
3750
3751 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
3752 {
3753 int rc = 0;
3754 struct TCP_Server_Info *server = ses->server;
3755
3756 /* only send once per connect */
3757 if (server->maxBuf != 0)
3758 return 0;
3759
3760 rc = CIFSSMBNegotiate(xid, ses);
3761 if (rc == -EAGAIN) {
3762 /* retry only once on 1st time connection */
3763 rc = CIFSSMBNegotiate(xid, ses);
3764 if (rc == -EAGAIN)
3765 rc = -EHOSTDOWN;
3766 }
3767 if (rc == 0) {
3768 spin_lock(&GlobalMid_Lock);
3769 if (server->tcpStatus == CifsNeedNegotiate)
3770 server->tcpStatus = CifsGood;
3771 else
3772 rc = -EHOSTDOWN;
3773 spin_unlock(&GlobalMid_Lock);
3774
3775 }
3776
3777 return rc;
3778 }
3779
3780
3781 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
3782 struct nls_table *nls_info)
3783 {
3784 int rc = 0;
3785 struct TCP_Server_Info *server = ses->server;
3786
3787 ses->flags = 0;
3788 ses->capabilities = server->capabilities;
3789 if (linuxExtEnabled == 0)
3790 ses->capabilities &= (~CAP_UNIX);
3791
3792 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3793 server->sec_mode, server->capabilities, server->timeAdj);
3794
3795 rc = CIFS_SessSetup(xid, ses, nls_info);
3796 if (rc) {
3797 cERROR(1, "Send error in SessSetup = %d", rc);
3798 } else {
3799 mutex_lock(&ses->server->srv_mutex);
3800 if (!server->session_estab) {
3801 server->session_key.response = ses->auth_key.response;
3802 server->session_key.len = ses->auth_key.len;
3803 server->sequence_number = 0x2;
3804 server->session_estab = true;
3805 ses->auth_key.response = NULL;
3806 }
3807 mutex_unlock(&server->srv_mutex);
3808
3809 cFYI(1, "CIFS Session Established successfully");
3810 spin_lock(&GlobalMid_Lock);
3811 ses->status = CifsGood;
3812 ses->need_reconnect = false;
3813 spin_unlock(&GlobalMid_Lock);
3814 }
3815
3816 kfree(ses->auth_key.response);
3817 ses->auth_key.response = NULL;
3818 ses->auth_key.len = 0;
3819 kfree(ses->ntlmssp);
3820 ses->ntlmssp = NULL;
3821
3822 return rc;
3823 }
3824
3825 static int
3826 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3827 {
3828 switch (ses->server->secType) {
3829 case Kerberos:
3830 vol->secFlg = CIFSSEC_MUST_KRB5;
3831 return 0;
3832 case NTLMv2:
3833 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3834 break;
3835 case NTLM:
3836 vol->secFlg = CIFSSEC_MUST_NTLM;
3837 break;
3838 case RawNTLMSSP:
3839 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3840 break;
3841 case LANMAN:
3842 vol->secFlg = CIFSSEC_MUST_LANMAN;
3843 break;
3844 }
3845
3846 return cifs_set_cifscreds(vol, ses);
3847 }
3848
3849 static struct cifs_tcon *
3850 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3851 {
3852 int rc;
3853 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3854 struct cifs_ses *ses;
3855 struct cifs_tcon *tcon = NULL;
3856 struct smb_vol *vol_info;
3857
3858 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3859 if (vol_info == NULL)
3860 return ERR_PTR(-ENOMEM);
3861
3862 vol_info->local_nls = cifs_sb->local_nls;
3863 vol_info->linux_uid = fsuid;
3864 vol_info->cred_uid = fsuid;
3865 vol_info->UNC = master_tcon->treeName;
3866 vol_info->retry = master_tcon->retry;
3867 vol_info->nocase = master_tcon->nocase;
3868 vol_info->local_lease = master_tcon->local_lease;
3869 vol_info->no_linux_ext = !master_tcon->unix_ext;
3870
3871 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3872 if (rc) {
3873 tcon = ERR_PTR(rc);
3874 goto out;
3875 }
3876
3877 /* get a reference for the same TCP session */
3878 spin_lock(&cifs_tcp_ses_lock);
3879 ++master_tcon->ses->server->srv_count;
3880 spin_unlock(&cifs_tcp_ses_lock);
3881
3882 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3883 if (IS_ERR(ses)) {
3884 tcon = (struct cifs_tcon *)ses;
3885 cifs_put_tcp_session(master_tcon->ses->server);
3886 goto out;
3887 }
3888
3889 tcon = cifs_get_tcon(ses, vol_info);
3890 if (IS_ERR(tcon)) {
3891 cifs_put_smb_ses(ses);
3892 goto out;
3893 }
3894
3895 if (ses->capabilities & CAP_UNIX)
3896 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3897 out:
3898 kfree(vol_info->username);
3899 kfree(vol_info->password);
3900 kfree(vol_info);
3901
3902 return tcon;
3903 }
3904
3905 struct cifs_tcon *
3906 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3907 {
3908 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3909 }
3910
3911 static int
3912 cifs_sb_tcon_pending_wait(void *unused)
3913 {
3914 schedule();
3915 return signal_pending(current) ? -ERESTARTSYS : 0;
3916 }
3917
3918 /* find and return a tlink with given uid */
3919 static struct tcon_link *
3920 tlink_rb_search(struct rb_root *root, uid_t uid)
3921 {
3922 struct rb_node *node = root->rb_node;
3923 struct tcon_link *tlink;
3924
3925 while (node) {
3926 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3927
3928 if (tlink->tl_uid > uid)
3929 node = node->rb_left;
3930 else if (tlink->tl_uid < uid)
3931 node = node->rb_right;
3932 else
3933 return tlink;
3934 }
3935 return NULL;
3936 }
3937
3938 /* insert a tcon_link into the tree */
3939 static void
3940 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3941 {
3942 struct rb_node **new = &(root->rb_node), *parent = NULL;
3943 struct tcon_link *tlink;
3944
3945 while (*new) {
3946 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3947 parent = *new;
3948
3949 if (tlink->tl_uid > new_tlink->tl_uid)
3950 new = &((*new)->rb_left);
3951 else
3952 new = &((*new)->rb_right);
3953 }
3954
3955 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3956 rb_insert_color(&new_tlink->tl_rbnode, root);
3957 }
3958
3959 /*
3960 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3961 * current task.
3962 *
3963 * If the superblock doesn't refer to a multiuser mount, then just return
3964 * the master tcon for the mount.
3965 *
3966 * First, search the rbtree for an existing tcon for this fsuid. If one
3967 * exists, then check to see if it's pending construction. If it is then wait
3968 * for construction to complete. Once it's no longer pending, check to see if
3969 * it failed and either return an error or retry construction, depending on
3970 * the timeout.
3971 *
3972 * If one doesn't exist then insert a new tcon_link struct into the tree and
3973 * try to construct a new one.
3974 */
3975 struct tcon_link *
3976 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3977 {
3978 int ret;
3979 uid_t fsuid = current_fsuid();
3980 struct tcon_link *tlink, *newtlink;
3981
3982 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3983 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3984
3985 spin_lock(&cifs_sb->tlink_tree_lock);
3986 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3987 if (tlink)
3988 cifs_get_tlink(tlink);
3989 spin_unlock(&cifs_sb->tlink_tree_lock);
3990
3991 if (tlink == NULL) {
3992 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3993 if (newtlink == NULL)
3994 return ERR_PTR(-ENOMEM);
3995 newtlink->tl_uid = fsuid;
3996 newtlink->tl_tcon = ERR_PTR(-EACCES);
3997 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3998 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3999 cifs_get_tlink(newtlink);
4000
4001 spin_lock(&cifs_sb->tlink_tree_lock);
4002 /* was one inserted after previous search? */
4003 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4004 if (tlink) {
4005 cifs_get_tlink(tlink);
4006 spin_unlock(&cifs_sb->tlink_tree_lock);
4007 kfree(newtlink);
4008 goto wait_for_construction;
4009 }
4010 tlink = newtlink;
4011 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4012 spin_unlock(&cifs_sb->tlink_tree_lock);
4013 } else {
4014 wait_for_construction:
4015 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4016 cifs_sb_tcon_pending_wait,
4017 TASK_INTERRUPTIBLE);
4018 if (ret) {
4019 cifs_put_tlink(tlink);
4020 return ERR_PTR(ret);
4021 }
4022
4023 /* if it's good, return it */
4024 if (!IS_ERR(tlink->tl_tcon))
4025 return tlink;
4026
4027 /* return error if we tried this already recently */
4028 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4029 cifs_put_tlink(tlink);
4030 return ERR_PTR(-EACCES);
4031 }
4032
4033 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4034 goto wait_for_construction;
4035 }
4036
4037 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4038 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4039 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4040
4041 if (IS_ERR(tlink->tl_tcon)) {
4042 cifs_put_tlink(tlink);
4043 return ERR_PTR(-EACCES);
4044 }
4045
4046 return tlink;
4047 }
4048
4049 /*
4050 * periodic workqueue job that scans tcon_tree for a superblock and closes
4051 * out tcons.
4052 */
4053 static void
4054 cifs_prune_tlinks(struct work_struct *work)
4055 {
4056 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4057 prune_tlinks.work);
4058 struct rb_root *root = &cifs_sb->tlink_tree;
4059 struct rb_node *node = rb_first(root);
4060 struct rb_node *tmp;
4061 struct tcon_link *tlink;
4062
4063 /*
4064 * Because we drop the spinlock in the loop in order to put the tlink
4065 * it's not guarded against removal of links from the tree. The only
4066 * places that remove entries from the tree are this function and
4067 * umounts. Because this function is non-reentrant and is canceled
4068 * before umount can proceed, this is safe.
4069 */
4070 spin_lock(&cifs_sb->tlink_tree_lock);
4071 node = rb_first(root);
4072 while (node != NULL) {
4073 tmp = node;
4074 node = rb_next(tmp);
4075 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4076
4077 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4078 atomic_read(&tlink->tl_count) != 0 ||
4079 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4080 continue;
4081
4082 cifs_get_tlink(tlink);
4083 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4084 rb_erase(tmp, root);
4085
4086 spin_unlock(&cifs_sb->tlink_tree_lock);
4087 cifs_put_tlink(tlink);
4088 spin_lock(&cifs_sb->tlink_tree_lock);
4089 }
4090 spin_unlock(&cifs_sb->tlink_tree_lock);
4091
4092 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
4093 TLINK_IDLE_EXPIRE);
4094 }