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