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