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