projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge commit 'v2.6.38-rc8' into x86/asm
[GitHub/mt8127/android_kernel_alcatel_ttab.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, 200) < 200) {
885 vol->username = value;
886 } else {
887 printk(KERN_WARNING "CIFS: username too long\n");
888 return 1;
889 }
890 } else if (strnicmp(data, "pass", 4) == 0) {
891 if (!value) {
892 vol->password = NULL;
893 continue;
894 } else if (value[0] == 0) {
895 /* check if string begins with double comma
896 since that would mean the password really
897 does start with a comma, and would not
898 indicate an empty string */
899 if (value[1] != separator[0]) {
900 vol->password = NULL;
901 continue;
902 }
903 }
904 temp_len = strlen(value);
905 /* removed password length check, NTLM passwords
906 can be arbitrarily long */
907
908 /* if comma in password, the string will be
909 prematurely null terminated. Commas in password are
910 specified across the cifs mount interface by a double
911 comma ie ,, and a comma used as in other cases ie ','
912 as a parameter delimiter/separator is single and due
913 to the strsep above is temporarily zeroed. */
914
915 /* NB: password legally can have multiple commas and
916 the only illegal character in a password is null */
917
918 if ((value[temp_len] == 0) &&
919 (value[temp_len+1] == separator[0])) {
920 /* reinsert comma */
921 value[temp_len] = separator[0];
922 temp_len += 2; /* move after second comma */
923 while (value[temp_len] != 0) {
924 if (value[temp_len] == separator[0]) {
925 if (value[temp_len+1] ==
926 separator[0]) {
927 /* skip second comma */
928 temp_len++;
929 } else {
930 /* single comma indicating start
931 of next parm */
932 break;
933 }
934 }
935 temp_len++;
936 }
937 if (value[temp_len] == 0) {
938 options = NULL;
939 } else {
940 value[temp_len] = 0;
941 /* point option to start of next parm */
942 options = value + temp_len + 1;
943 }
944 /* go from value to value + temp_len condensing
945 double commas to singles. Note that this ends up
946 allocating a few bytes too many, which is ok */
947 vol->password = kzalloc(temp_len, GFP_KERNEL);
948 if (vol->password == NULL) {
949 printk(KERN_WARNING "CIFS: no memory "
950 "for password\n");
951 return 1;
952 }
953 for (i = 0, j = 0; i < temp_len; i++, j++) {
954 vol->password[j] = value[i];
955 if (value[i] == separator[0]
956 && value[i+1] == separator[0]) {
957 /* skip second comma */
958 i++;
959 }
960 }
961 vol->password[j] = 0;
962 } else {
963 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
964 if (vol->password == NULL) {
965 printk(KERN_WARNING "CIFS: no memory "
966 "for password\n");
967 return 1;
968 }
969 strcpy(vol->password, value);
970 }
971 } else if (!strnicmp(data, "ip", 2) ||
972 !strnicmp(data, "addr", 4)) {
973 if (!value || !*value) {
974 vol->UNCip = NULL;
975 } else if (strnlen(value, INET6_ADDRSTRLEN) <
976 INET6_ADDRSTRLEN) {
977 vol->UNCip = value;
978 } else {
979 printk(KERN_WARNING "CIFS: ip address "
980 "too long\n");
981 return 1;
982 }
983 } else if (strnicmp(data, "sec", 3) == 0) {
984 if (!value || !*value) {
985 cERROR(1, "no security value specified");
986 continue;
987 } else if (strnicmp(value, "krb5i", 5) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_KRB5 |
989 CIFSSEC_MUST_SIGN;
990 } else if (strnicmp(value, "krb5p", 5) == 0) {
991 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
992 CIFSSEC_MAY_KRB5; */
993 cERROR(1, "Krb5 cifs privacy not supported");
994 return 1;
995 } else if (strnicmp(value, "krb5", 4) == 0) {
996 vol->secFlg |= CIFSSEC_MAY_KRB5;
997 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
998 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
999 CIFSSEC_MUST_SIGN;
1000 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1001 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1002 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1003 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1004 CIFSSEC_MUST_SIGN;
1005 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1006 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1007 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1008 vol->secFlg |= CIFSSEC_MAY_NTLM |
1009 CIFSSEC_MUST_SIGN;
1010 } else if (strnicmp(value, "ntlm", 4) == 0) {
1011 /* ntlm is default so can be turned off too */
1012 vol->secFlg |= CIFSSEC_MAY_NTLM;
1013 } else if (strnicmp(value, "nontlm", 6) == 0) {
1014 /* BB is there a better way to do this? */
1015 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1016 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1017 } else if (strnicmp(value, "lanman", 6) == 0) {
1018 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1019 #endif
1020 } else if (strnicmp(value, "none", 4) == 0) {
1021 vol->nullauth = 1;
1022 } else {
1023 cERROR(1, "bad security option: %s", value);
1024 return 1;
1025 }
1026 } else if ((strnicmp(data, "unc", 3) == 0)
1027 || (strnicmp(data, "target", 6) == 0)
1028 || (strnicmp(data, "path", 4) == 0)) {
1029 if (!value || !*value) {
1030 printk(KERN_WARNING "CIFS: invalid path to "
1031 "network resource\n");
1032 return 1; /* needs_arg; */
1033 }
1034 if ((temp_len = strnlen(value, 300)) < 300) {
1035 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1036 if (vol->UNC == NULL)
1037 return 1;
1038 strcpy(vol->UNC, value);
1039 if (strncmp(vol->UNC, "//", 2) == 0) {
1040 vol->UNC[0] = '\\';
1041 vol->UNC[1] = '\\';
1042 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1043 printk(KERN_WARNING
1044 "CIFS: UNC Path does not begin "
1045 "with // or \\\\ \n");
1046 return 1;
1047 }
1048 } else {
1049 printk(KERN_WARNING "CIFS: UNC name too long\n");
1050 return 1;
1051 }
1052 } else if ((strnicmp(data, "domain", 3) == 0)
1053 || (strnicmp(data, "workgroup", 5) == 0)) {
1054 if (!value || !*value) {
1055 printk(KERN_WARNING "CIFS: invalid domain name\n");
1056 return 1; /* needs_arg; */
1057 }
1058 /* BB are there cases in which a comma can be valid in
1059 a domain name and need special handling? */
1060 if (strnlen(value, 256) < 256) {
1061 vol->domainname = value;
1062 cFYI(1, "Domain name set");
1063 } else {
1064 printk(KERN_WARNING "CIFS: domain name too "
1065 "long\n");
1066 return 1;
1067 }
1068 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1069 vol->srcaddr.ss_family = AF_UNSPEC;
1070
1071 if (!value || !*value) {
1072 printk(KERN_WARNING "CIFS: srcaddr value"
1073 " not specified.\n");
1074 return 1; /* needs_arg; */
1075 }
1076 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1077 value, strlen(value));
1078 if (i == 0) {
1079 printk(KERN_WARNING "CIFS: Could not parse"
1080 " srcaddr: %s\n",
1081 value);
1082 return 1;
1083 }
1084 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1085 if (!value || !*value) {
1086 printk(KERN_WARNING
1087 "CIFS: invalid path prefix\n");
1088 return 1; /* needs_argument */
1089 }
1090 if ((temp_len = strnlen(value, 1024)) < 1024) {
1091 if (value[0] != '/')
1092 temp_len++; /* missing leading slash */
1093 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1094 if (vol->prepath == NULL)
1095 return 1;
1096 if (value[0] != '/') {
1097 vol->prepath[0] = '/';
1098 strcpy(vol->prepath+1, value);
1099 } else
1100 strcpy(vol->prepath, value);
1101 cFYI(1, "prefix path %s", vol->prepath);
1102 } else {
1103 printk(KERN_WARNING "CIFS: prefix too long\n");
1104 return 1;
1105 }
1106 } else if (strnicmp(data, "iocharset", 9) == 0) {
1107 if (!value || !*value) {
1108 printk(KERN_WARNING "CIFS: invalid iocharset "
1109 "specified\n");
1110 return 1; /* needs_arg; */
1111 }
1112 if (strnlen(value, 65) < 65) {
1113 if (strnicmp(value, "default", 7))
1114 vol->iocharset = value;
1115 /* if iocharset not set then load_nls_default
1116 is used by caller */
1117 cFYI(1, "iocharset set to %s", value);
1118 } else {
1119 printk(KERN_WARNING "CIFS: iocharset name "
1120 "too long.\n");
1121 return 1;
1122 }
1123 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1124 vol->linux_uid = simple_strtoul(value, &value, 0);
1125 uid_specified = true;
1126 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1127 vol->cred_uid = simple_strtoul(value, &value, 0);
1128 } else if (!strnicmp(data, "forceuid", 8)) {
1129 override_uid = 1;
1130 } else if (!strnicmp(data, "noforceuid", 10)) {
1131 override_uid = 0;
1132 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1133 vol->linux_gid = simple_strtoul(value, &value, 0);
1134 gid_specified = true;
1135 } else if (!strnicmp(data, "forcegid", 8)) {
1136 override_gid = 1;
1137 } else if (!strnicmp(data, "noforcegid", 10)) {
1138 override_gid = 0;
1139 } else if (strnicmp(data, "file_mode", 4) == 0) {
1140 if (value && *value) {
1141 vol->file_mode =
1142 simple_strtoul(value, &value, 0);
1143 }
1144 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1145 if (value && *value) {
1146 vol->dir_mode =
1147 simple_strtoul(value, &value, 0);
1148 }
1149 } else if (strnicmp(data, "dirmode", 4) == 0) {
1150 if (value && *value) {
1151 vol->dir_mode =
1152 simple_strtoul(value, &value, 0);
1153 }
1154 } else if (strnicmp(data, "port", 4) == 0) {
1155 if (value && *value) {
1156 vol->port =
1157 simple_strtoul(value, &value, 0);
1158 }
1159 } else if (strnicmp(data, "rsize", 5) == 0) {
1160 if (value && *value) {
1161 vol->rsize =
1162 simple_strtoul(value, &value, 0);
1163 }
1164 } else if (strnicmp(data, "wsize", 5) == 0) {
1165 if (value && *value) {
1166 vol->wsize =
1167 simple_strtoul(value, &value, 0);
1168 }
1169 } else if (strnicmp(data, "sockopt", 5) == 0) {
1170 if (!value || !*value) {
1171 cERROR(1, "no socket option specified");
1172 continue;
1173 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1174 vol->sockopt_tcp_nodelay = 1;
1175 }
1176 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1177 if (!value || !*value || (*value == ' ')) {
1178 cFYI(1, "invalid (empty) netbiosname");
1179 } else {
1180 memset(vol->source_rfc1001_name, 0x20,
1181 RFC1001_NAME_LEN);
1182 /*
1183 * FIXME: are there cases in which a comma can
1184 * be valid in workstation netbios name (and
1185 * need special handling)?
1186 */
1187 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1188 /* don't ucase netbiosname for user */
1189 if (value[i] == 0)
1190 break;
1191 vol->source_rfc1001_name[i] = value[i];
1192 }
1193 /* The string has 16th byte zero still from
1194 set at top of the function */
1195 if (i == RFC1001_NAME_LEN && value[i] != 0)
1196 printk(KERN_WARNING "CIFS: netbiosname"
1197 " longer than 15 truncated.\n");
1198 }
1199 } else if (strnicmp(data, "servern", 7) == 0) {
1200 /* servernetbiosname specified override *SMBSERVER */
1201 if (!value || !*value || (*value == ' ')) {
1202 cFYI(1, "empty server netbiosname specified");
1203 } else {
1204 /* last byte, type, is 0x20 for servr type */
1205 memset(vol->target_rfc1001_name, 0x20,
1206 RFC1001_NAME_LEN_WITH_NULL);
1207
1208 for (i = 0; i < 15; i++) {
1209 /* BB are there cases in which a comma can be
1210 valid in this workstation netbios name
1211 (and need special handling)? */
1212
1213 /* user or mount helper must uppercase
1214 the netbiosname */
1215 if (value[i] == 0)
1216 break;
1217 else
1218 vol->target_rfc1001_name[i] =
1219 value[i];
1220 }
1221 /* The string has 16th byte zero still from
1222 set at top of the function */
1223 if (i == RFC1001_NAME_LEN && value[i] != 0)
1224 printk(KERN_WARNING "CIFS: server net"
1225 "biosname longer than 15 truncated.\n");
1226 }
1227 } else if (strnicmp(data, "actimeo", 7) == 0) {
1228 if (value && *value) {
1229 vol->actimeo = HZ * simple_strtoul(value,
1230 &value, 0);
1231 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1232 cERROR(1, "CIFS: attribute cache"
1233 "timeout too large");
1234 return 1;
1235 }
1236 }
1237 } else if (strnicmp(data, "credentials", 4) == 0) {
1238 /* ignore */
1239 } else if (strnicmp(data, "version", 3) == 0) {
1240 /* ignore */
1241 } else if (strnicmp(data, "guest", 5) == 0) {
1242 /* ignore */
1243 } else if (strnicmp(data, "rw", 2) == 0) {
1244 /* ignore */
1245 } else if (strnicmp(data, "ro", 2) == 0) {
1246 /* ignore */
1247 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1248 vol->noblocksnd = 1;
1249 } else if (strnicmp(data, "noautotune", 10) == 0) {
1250 vol->noautotune = 1;
1251 } else if ((strnicmp(data, "suid", 4) == 0) ||
1252 (strnicmp(data, "nosuid", 6) == 0) ||
1253 (strnicmp(data, "exec", 4) == 0) ||
1254 (strnicmp(data, "noexec", 6) == 0) ||
1255 (strnicmp(data, "nodev", 5) == 0) ||
1256 (strnicmp(data, "noauto", 6) == 0) ||
1257 (strnicmp(data, "dev", 3) == 0)) {
1258 /* The mount tool or mount.cifs helper (if present)
1259 uses these opts to set flags, and the flags are read
1260 by the kernel vfs layer before we get here (ie
1261 before read super) so there is no point trying to
1262 parse these options again and set anything and it
1263 is ok to just ignore them */
1264 continue;
1265 } else if (strnicmp(data, "hard", 4) == 0) {
1266 vol->retry = 1;
1267 } else if (strnicmp(data, "soft", 4) == 0) {
1268 vol->retry = 0;
1269 } else if (strnicmp(data, "perm", 4) == 0) {
1270 vol->noperm = 0;
1271 } else if (strnicmp(data, "noperm", 6) == 0) {
1272 vol->noperm = 1;
1273 } else if (strnicmp(data, "mapchars", 8) == 0) {
1274 vol->remap = 1;
1275 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1276 vol->remap = 0;
1277 } else if (strnicmp(data, "sfu", 3) == 0) {
1278 vol->sfu_emul = 1;
1279 } else if (strnicmp(data, "nosfu", 5) == 0) {
1280 vol->sfu_emul = 0;
1281 } else if (strnicmp(data, "nodfs", 5) == 0) {
1282 vol->nodfs = 1;
1283 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1284 vol->posix_paths = 1;
1285 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1286 vol->posix_paths = 0;
1287 } else if (strnicmp(data, "nounix", 6) == 0) {
1288 vol->no_linux_ext = 1;
1289 } else if (strnicmp(data, "nolinux", 7) == 0) {
1290 vol->no_linux_ext = 1;
1291 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1292 (strnicmp(data, "ignorecase", 10) == 0)) {
1293 vol->nocase = 1;
1294 } else if (strnicmp(data, "mand", 4) == 0) {
1295 /* ignore */
1296 } else if (strnicmp(data, "nomand", 6) == 0) {
1297 /* ignore */
1298 } else if (strnicmp(data, "_netdev", 7) == 0) {
1299 /* ignore */
1300 } else if (strnicmp(data, "brl", 3) == 0) {
1301 vol->nobrl = 0;
1302 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1303 (strnicmp(data, "nolock", 6) == 0)) {
1304 vol->nobrl = 1;
1305 /* turn off mandatory locking in mode
1306 if remote locking is turned off since the
1307 local vfs will do advisory */
1308 if (vol->file_mode ==
1309 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1310 vol->file_mode = S_IALLUGO;
1311 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1312 /* will take the shorter form "forcemand" as well */
1313 /* This mount option will force use of mandatory
1314 (DOS/Windows style) byte range locks, instead of
1315 using posix advisory byte range locks, even if the
1316 Unix extensions are available and posix locks would
1317 be supported otherwise. If Unix extensions are not
1318 negotiated this has no effect since mandatory locks
1319 would be used (mandatory locks is all that those
1320 those servers support) */
1321 vol->mand_lock = 1;
1322 } else if (strnicmp(data, "setuids", 7) == 0) {
1323 vol->setuids = 1;
1324 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1325 vol->setuids = 0;
1326 } else if (strnicmp(data, "dynperm", 7) == 0) {
1327 vol->dynperm = true;
1328 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1329 vol->dynperm = false;
1330 } else if (strnicmp(data, "nohard", 6) == 0) {
1331 vol->retry = 0;
1332 } else if (strnicmp(data, "nosoft", 6) == 0) {
1333 vol->retry = 1;
1334 } else if (strnicmp(data, "nointr", 6) == 0) {
1335 vol->intr = 0;
1336 } else if (strnicmp(data, "intr", 4) == 0) {
1337 vol->intr = 1;
1338 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1339 vol->nostrictsync = 1;
1340 } else if (strnicmp(data, "strictsync", 10) == 0) {
1341 vol->nostrictsync = 0;
1342 } else if (strnicmp(data, "serverino", 7) == 0) {
1343 vol->server_ino = 1;
1344 } else if (strnicmp(data, "noserverino", 9) == 0) {
1345 vol->server_ino = 0;
1346 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1347 vol->cifs_acl = 1;
1348 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1349 vol->cifs_acl = 0;
1350 } else if (strnicmp(data, "acl", 3) == 0) {
1351 vol->no_psx_acl = 0;
1352 } else if (strnicmp(data, "noacl", 5) == 0) {
1353 vol->no_psx_acl = 1;
1354 } else if (strnicmp(data, "locallease", 6) == 0) {
1355 vol->local_lease = 1;
1356 } else if (strnicmp(data, "sign", 4) == 0) {
1357 vol->secFlg |= CIFSSEC_MUST_SIGN;
1358 } else if (strnicmp(data, "seal", 4) == 0) {
1359 /* we do not do the following in secFlags because seal
1360 is a per tree connection (mount) not a per socket
1361 or per-smb connection option in the protocol */
1362 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1363 vol->seal = 1;
1364 } else if (strnicmp(data, "direct", 6) == 0) {
1365 vol->direct_io = 1;
1366 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1367 vol->direct_io = 1;
1368 } else if (strnicmp(data, "strictcache", 11) == 0) {
1369 vol->strict_io = 1;
1370 } else if (strnicmp(data, "noac", 4) == 0) {
1371 printk(KERN_WARNING "CIFS: Mount option noac not "
1372 "supported. Instead set "
1373 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1374 } else if (strnicmp(data, "fsc", 3) == 0) {
1375 #ifndef CONFIG_CIFS_FSCACHE
1376 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1377 "kernel config option set");
1378 return 1;
1379 #endif
1380 vol->fsc = true;
1381 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1382 vol->mfsymlinks = true;
1383 } else if (strnicmp(data, "multiuser", 8) == 0) {
1384 vol->multiuser = true;
1385 } else
1386 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1387 data);
1388 }
1389 if (vol->UNC == NULL) {
1390 if (devname == NULL) {
1391 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1392 "target\n");
1393 return 1;
1394 }
1395 if ((temp_len = strnlen(devname, 300)) < 300) {
1396 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1397 if (vol->UNC == NULL)
1398 return 1;
1399 strcpy(vol->UNC, devname);
1400 if (strncmp(vol->UNC, "//", 2) == 0) {
1401 vol->UNC[0] = '\\';
1402 vol->UNC[1] = '\\';
1403 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1404 printk(KERN_WARNING "CIFS: UNC Path does not "
1405 "begin with // or \\\\ \n");
1406 return 1;
1407 }
1408 value = strpbrk(vol->UNC+2, "/\\");
1409 if (value)
1410 *value = '\\';
1411 } else {
1412 printk(KERN_WARNING "CIFS: UNC name too long\n");
1413 return 1;
1414 }
1415 }
1416
1417 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1418 cERROR(1, "Multiuser mounts currently require krb5 "
1419 "authentication!");
1420 return 1;
1421 }
1422
1423 if (vol->UNCip == NULL)
1424 vol->UNCip = &vol->UNC[2];
1425
1426 if (uid_specified)
1427 vol->override_uid = override_uid;
1428 else if (override_uid == 1)
1429 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1430 "specified with no uid= option.\n");
1431
1432 if (gid_specified)
1433 vol->override_gid = override_gid;
1434 else if (override_gid == 1)
1435 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1436 "specified with no gid= option.\n");
1437
1438 return 0;
1439 }
1440
1441 /** Returns true if srcaddr isn't specified and rhs isn't
1442 * specified, or if srcaddr is specified and
1443 * matches the IP address of the rhs argument.
1444 */
1445 static bool
1446 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1447 {
1448 switch (srcaddr->sa_family) {
1449 case AF_UNSPEC:
1450 return (rhs->sa_family == AF_UNSPEC);
1451 case AF_INET: {
1452 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1453 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1454 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1455 }
1456 case AF_INET6: {
1457 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1458 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1459 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1460 }
1461 default:
1462 WARN_ON(1);
1463 return false; /* don't expect to be here */
1464 }
1465 }
1466
1467 /*
1468 * If no port is specified in addr structure, we try to match with 445 port
1469 * and if it fails - with 139 ports. It should be called only if address
1470 * families of server and addr are equal.
1471 */
1472 static bool
1473 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1474 {
1475 unsigned short int port, *sport;
1476
1477 switch (addr->sa_family) {
1478 case AF_INET:
1479 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1480 port = ((struct sockaddr_in *) addr)->sin_port;
1481 break;
1482 case AF_INET6:
1483 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1484 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1485 break;
1486 default:
1487 WARN_ON(1);
1488 return false;
1489 }
1490
1491 if (!port) {
1492 port = htons(CIFS_PORT);
1493 if (port == *sport)
1494 return true;
1495
1496 port = htons(RFC1001_PORT);
1497 }
1498
1499 return port == *sport;
1500 }
1501
1502 static bool
1503 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1504 struct sockaddr *srcaddr)
1505 {
1506 switch (addr->sa_family) {
1507 case AF_INET: {
1508 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1509 struct sockaddr_in *srv_addr4 =
1510 (struct sockaddr_in *)&server->dstaddr;
1511
1512 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1513 return false;
1514 break;
1515 }
1516 case AF_INET6: {
1517 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1518 struct sockaddr_in6 *srv_addr6 =
1519 (struct sockaddr_in6 *)&server->dstaddr;
1520
1521 if (!ipv6_addr_equal(&addr6->sin6_addr,
1522 &srv_addr6->sin6_addr))
1523 return false;
1524 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1525 return false;
1526 break;
1527 }
1528 default:
1529 WARN_ON(1);
1530 return false; /* don't expect to be here */
1531 }
1532
1533 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1534 return false;
1535
1536 return true;
1537 }
1538
1539 static bool
1540 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1541 {
1542 unsigned int secFlags;
1543
1544 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1545 secFlags = vol->secFlg;
1546 else
1547 secFlags = global_secflags | vol->secFlg;
1548
1549 switch (server->secType) {
1550 case LANMAN:
1551 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1552 return false;
1553 break;
1554 case NTLMv2:
1555 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1556 return false;
1557 break;
1558 case NTLM:
1559 if (!(secFlags & CIFSSEC_MAY_NTLM))
1560 return false;
1561 break;
1562 case Kerberos:
1563 if (!(secFlags & CIFSSEC_MAY_KRB5))
1564 return false;
1565 break;
1566 case RawNTLMSSP:
1567 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1568 return false;
1569 break;
1570 default:
1571 /* shouldn't happen */
1572 return false;
1573 }
1574
1575 /* now check if signing mode is acceptible */
1576 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1577 (server->secMode & SECMODE_SIGN_REQUIRED))
1578 return false;
1579 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1580 (server->secMode &
1581 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1582 return false;
1583
1584 return true;
1585 }
1586
1587 static struct TCP_Server_Info *
1588 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1589 {
1590 struct TCP_Server_Info *server;
1591
1592 spin_lock(&cifs_tcp_ses_lock);
1593 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1594 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1595 continue;
1596
1597 if (!match_address(server, addr,
1598 (struct sockaddr *)&vol->srcaddr))
1599 continue;
1600
1601 if (!match_port(server, addr))
1602 continue;
1603
1604 if (!match_security(server, vol))
1605 continue;
1606
1607 ++server->srv_count;
1608 spin_unlock(&cifs_tcp_ses_lock);
1609 cFYI(1, "Existing tcp session with server found");
1610 return server;
1611 }
1612 spin_unlock(&cifs_tcp_ses_lock);
1613 return NULL;
1614 }
1615
1616 static void
1617 cifs_put_tcp_session(struct TCP_Server_Info *server)
1618 {
1619 struct task_struct *task;
1620
1621 spin_lock(&cifs_tcp_ses_lock);
1622 if (--server->srv_count > 0) {
1623 spin_unlock(&cifs_tcp_ses_lock);
1624 return;
1625 }
1626
1627 put_net(cifs_net_ns(server));
1628
1629 list_del_init(&server->tcp_ses_list);
1630 spin_unlock(&cifs_tcp_ses_lock);
1631
1632 cancel_delayed_work_sync(&server->echo);
1633
1634 spin_lock(&GlobalMid_Lock);
1635 server->tcpStatus = CifsExiting;
1636 spin_unlock(&GlobalMid_Lock);
1637
1638 cifs_crypto_shash_release(server);
1639 cifs_fscache_release_client_cookie(server);
1640
1641 kfree(server->session_key.response);
1642 server->session_key.response = NULL;
1643 server->session_key.len = 0;
1644
1645 task = xchg(&server->tsk, NULL);
1646 if (task)
1647 force_sig(SIGKILL, task);
1648 }
1649
1650 static struct TCP_Server_Info *
1651 cifs_get_tcp_session(struct smb_vol *volume_info)
1652 {
1653 struct TCP_Server_Info *tcp_ses = NULL;
1654 struct sockaddr_storage addr;
1655 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1656 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1657 int rc;
1658
1659 memset(&addr, 0, sizeof(struct sockaddr_storage));
1660
1661 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1662
1663 if (volume_info->UNCip && volume_info->UNC) {
1664 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1665 volume_info->UNCip,
1666 strlen(volume_info->UNCip),
1667 volume_info->port);
1668 if (!rc) {
1669 /* we failed translating address */
1670 rc = -EINVAL;
1671 goto out_err;
1672 }
1673 } else if (volume_info->UNCip) {
1674 /* BB using ip addr as tcp_ses name to connect to the
1675 DFS root below */
1676 cERROR(1, "Connecting to DFS root not implemented yet");
1677 rc = -EINVAL;
1678 goto out_err;
1679 } else /* which tcp_sess DFS root would we conect to */ {
1680 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1681 "unc=//192.168.1.100/public) specified");
1682 rc = -EINVAL;
1683 goto out_err;
1684 }
1685
1686 /* see if we already have a matching tcp_ses */
1687 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1688 if (tcp_ses)
1689 return tcp_ses;
1690
1691 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1692 if (!tcp_ses) {
1693 rc = -ENOMEM;
1694 goto out_err;
1695 }
1696
1697 rc = cifs_crypto_shash_allocate(tcp_ses);
1698 if (rc) {
1699 cERROR(1, "could not setup hash structures rc %d", rc);
1700 goto out_err;
1701 }
1702
1703 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1704 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1705 if (IS_ERR(tcp_ses->hostname)) {
1706 rc = PTR_ERR(tcp_ses->hostname);
1707 goto out_err_crypto_release;
1708 }
1709
1710 tcp_ses->noblocksnd = volume_info->noblocksnd;
1711 tcp_ses->noautotune = volume_info->noautotune;
1712 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1713 atomic_set(&tcp_ses->inFlight, 0);
1714 init_waitqueue_head(&tcp_ses->response_q);
1715 init_waitqueue_head(&tcp_ses->request_q);
1716 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1717 mutex_init(&tcp_ses->srv_mutex);
1718 memcpy(tcp_ses->workstation_RFC1001_name,
1719 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1720 memcpy(tcp_ses->server_RFC1001_name,
1721 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1722 tcp_ses->session_estab = false;
1723 tcp_ses->sequence_number = 0;
1724 tcp_ses->lstrp = jiffies;
1725 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1726 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1727 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1728
1729 /*
1730 * at this point we are the only ones with the pointer
1731 * to the struct since the kernel thread not created yet
1732 * no need to spinlock this init of tcpStatus or srv_count
1733 */
1734 tcp_ses->tcpStatus = CifsNew;
1735 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1736 sizeof(tcp_ses->srcaddr));
1737 ++tcp_ses->srv_count;
1738
1739 if (addr.ss_family == AF_INET6) {
1740 cFYI(1, "attempting ipv6 connect");
1741 /* BB should we allow ipv6 on port 139? */
1742 /* other OS never observed in Wild doing 139 with v6 */
1743 memcpy(&tcp_ses->dstaddr, sin_server6,
1744 sizeof(struct sockaddr_in6));
1745 } else
1746 memcpy(&tcp_ses->dstaddr, sin_server,
1747 sizeof(struct sockaddr_in));
1748
1749 rc = ip_connect(tcp_ses);
1750 if (rc < 0) {
1751 cERROR(1, "Error connecting to socket. Aborting operation");
1752 goto out_err_crypto_release;
1753 }
1754
1755 /*
1756 * since we're in a cifs function already, we know that
1757 * this will succeed. No need for try_module_get().
1758 */
1759 __module_get(THIS_MODULE);
1760 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1761 tcp_ses, "cifsd");
1762 if (IS_ERR(tcp_ses->tsk)) {
1763 rc = PTR_ERR(tcp_ses->tsk);
1764 cERROR(1, "error %d create cifsd thread", rc);
1765 module_put(THIS_MODULE);
1766 goto out_err_crypto_release;
1767 }
1768
1769 /* thread spawned, put it on the list */
1770 spin_lock(&cifs_tcp_ses_lock);
1771 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1772 spin_unlock(&cifs_tcp_ses_lock);
1773
1774 cifs_fscache_get_client_cookie(tcp_ses);
1775
1776 /* queue echo request delayed work */
1777 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1778
1779 return tcp_ses;
1780
1781 out_err_crypto_release:
1782 cifs_crypto_shash_release(tcp_ses);
1783
1784 put_net(cifs_net_ns(tcp_ses));
1785
1786 out_err:
1787 if (tcp_ses) {
1788 if (!IS_ERR(tcp_ses->hostname))
1789 kfree(tcp_ses->hostname);
1790 if (tcp_ses->ssocket)
1791 sock_release(tcp_ses->ssocket);
1792 kfree(tcp_ses);
1793 }
1794 return ERR_PTR(rc);
1795 }
1796
1797 static struct cifsSesInfo *
1798 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1799 {
1800 struct cifsSesInfo *ses;
1801
1802 spin_lock(&cifs_tcp_ses_lock);
1803 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1804 switch (server->secType) {
1805 case Kerberos:
1806 if (vol->cred_uid != ses->cred_uid)
1807 continue;
1808 break;
1809 default:
1810 /* anything else takes username/password */
1811 if (strncmp(ses->userName, vol->username,
1812 MAX_USERNAME_SIZE))
1813 continue;
1814 if (strlen(vol->username) != 0 &&
1815 ses->password != NULL &&
1816 strncmp(ses->password,
1817 vol->password ? vol->password : "",
1818 MAX_PASSWORD_SIZE))
1819 continue;
1820 }
1821 ++ses->ses_count;
1822 spin_unlock(&cifs_tcp_ses_lock);
1823 return ses;
1824 }
1825 spin_unlock(&cifs_tcp_ses_lock);
1826 return NULL;
1827 }
1828
1829 static void
1830 cifs_put_smb_ses(struct cifsSesInfo *ses)
1831 {
1832 int xid;
1833 struct TCP_Server_Info *server = ses->server;
1834
1835 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1836 spin_lock(&cifs_tcp_ses_lock);
1837 if (--ses->ses_count > 0) {
1838 spin_unlock(&cifs_tcp_ses_lock);
1839 return;
1840 }
1841
1842 list_del_init(&ses->smb_ses_list);
1843 spin_unlock(&cifs_tcp_ses_lock);
1844
1845 if (ses->status == CifsGood) {
1846 xid = GetXid();
1847 CIFSSMBLogoff(xid, ses);
1848 _FreeXid(xid);
1849 }
1850 sesInfoFree(ses);
1851 cifs_put_tcp_session(server);
1852 }
1853
1854 static struct cifsSesInfo *
1855 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1856 {
1857 int rc = -ENOMEM, xid;
1858 struct cifsSesInfo *ses;
1859 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1860 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1861
1862 xid = GetXid();
1863
1864 ses = cifs_find_smb_ses(server, volume_info);
1865 if (ses) {
1866 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1867
1868 mutex_lock(&ses->session_mutex);
1869 rc = cifs_negotiate_protocol(xid, ses);
1870 if (rc) {
1871 mutex_unlock(&ses->session_mutex);
1872 /* problem -- put our ses reference */
1873 cifs_put_smb_ses(ses);
1874 FreeXid(xid);
1875 return ERR_PTR(rc);
1876 }
1877 if (ses->need_reconnect) {
1878 cFYI(1, "Session needs reconnect");
1879 rc = cifs_setup_session(xid, ses,
1880 volume_info->local_nls);
1881 if (rc) {
1882 mutex_unlock(&ses->session_mutex);
1883 /* problem -- put our reference */
1884 cifs_put_smb_ses(ses);
1885 FreeXid(xid);
1886 return ERR_PTR(rc);
1887 }
1888 }
1889 mutex_unlock(&ses->session_mutex);
1890
1891 /* existing SMB ses has a server reference already */
1892 cifs_put_tcp_session(server);
1893 FreeXid(xid);
1894 return ses;
1895 }
1896
1897 cFYI(1, "Existing smb sess not found");
1898 ses = sesInfoAlloc();
1899 if (ses == NULL)
1900 goto get_ses_fail;
1901
1902 /* new SMB session uses our server ref */
1903 ses->server = server;
1904 if (server->dstaddr.ss_family == AF_INET6)
1905 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1906 else
1907 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1908
1909 if (volume_info->username)
1910 strncpy(ses->userName, volume_info->username,
1911 MAX_USERNAME_SIZE);
1912
1913 /* volume_info->password freed at unmount */
1914 if (volume_info->password) {
1915 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1916 if (!ses->password)
1917 goto get_ses_fail;
1918 }
1919 if (volume_info->domainname) {
1920 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1921 if (!ses->domainName)
1922 goto get_ses_fail;
1923 }
1924 ses->cred_uid = volume_info->cred_uid;
1925 ses->linux_uid = volume_info->linux_uid;
1926 ses->overrideSecFlg = volume_info->secFlg;
1927
1928 mutex_lock(&ses->session_mutex);
1929 rc = cifs_negotiate_protocol(xid, ses);
1930 if (!rc)
1931 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1932 mutex_unlock(&ses->session_mutex);
1933 if (rc)
1934 goto get_ses_fail;
1935
1936 /* success, put it on the list */
1937 spin_lock(&cifs_tcp_ses_lock);
1938 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1939 spin_unlock(&cifs_tcp_ses_lock);
1940
1941 FreeXid(xid);
1942 return ses;
1943
1944 get_ses_fail:
1945 sesInfoFree(ses);
1946 FreeXid(xid);
1947 return ERR_PTR(rc);
1948 }
1949
1950 static struct cifsTconInfo *
1951 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1952 {
1953 struct list_head *tmp;
1954 struct cifsTconInfo *tcon;
1955
1956 spin_lock(&cifs_tcp_ses_lock);
1957 list_for_each(tmp, &ses->tcon_list) {
1958 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1959 if (tcon->tidStatus == CifsExiting)
1960 continue;
1961 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1962 continue;
1963
1964 ++tcon->tc_count;
1965 spin_unlock(&cifs_tcp_ses_lock);
1966 return tcon;
1967 }
1968 spin_unlock(&cifs_tcp_ses_lock);
1969 return NULL;
1970 }
1971
1972 static void
1973 cifs_put_tcon(struct cifsTconInfo *tcon)
1974 {
1975 int xid;
1976 struct cifsSesInfo *ses = tcon->ses;
1977
1978 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1979 spin_lock(&cifs_tcp_ses_lock);
1980 if (--tcon->tc_count > 0) {
1981 spin_unlock(&cifs_tcp_ses_lock);
1982 return;
1983 }
1984
1985 list_del_init(&tcon->tcon_list);
1986 spin_unlock(&cifs_tcp_ses_lock);
1987
1988 xid = GetXid();
1989 CIFSSMBTDis(xid, tcon);
1990 _FreeXid(xid);
1991
1992 cifs_fscache_release_super_cookie(tcon);
1993 tconInfoFree(tcon);
1994 cifs_put_smb_ses(ses);
1995 }
1996
1997 static struct cifsTconInfo *
1998 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1999 {
2000 int rc, xid;
2001 struct cifsTconInfo *tcon;
2002
2003 tcon = cifs_find_tcon(ses, volume_info->UNC);
2004 if (tcon) {
2005 cFYI(1, "Found match on UNC path");
2006 /* existing tcon already has a reference */
2007 cifs_put_smb_ses(ses);
2008 if (tcon->seal != volume_info->seal)
2009 cERROR(1, "transport encryption setting "
2010 "conflicts with existing tid");
2011 return tcon;
2012 }
2013
2014 tcon = tconInfoAlloc();
2015 if (tcon == NULL) {
2016 rc = -ENOMEM;
2017 goto out_fail;
2018 }
2019
2020 tcon->ses = ses;
2021 if (volume_info->password) {
2022 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2023 if (!tcon->password) {
2024 rc = -ENOMEM;
2025 goto out_fail;
2026 }
2027 }
2028
2029 if (strchr(volume_info->UNC + 3, '\\') == NULL
2030 && strchr(volume_info->UNC + 3, '/') == NULL) {
2031 cERROR(1, "Missing share name");
2032 rc = -ENODEV;
2033 goto out_fail;
2034 }
2035
2036 /* BB Do we need to wrap session_mutex around
2037 * this TCon call and Unix SetFS as
2038 * we do on SessSetup and reconnect? */
2039 xid = GetXid();
2040 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2041 FreeXid(xid);
2042 cFYI(1, "CIFS Tcon rc = %d", rc);
2043 if (rc)
2044 goto out_fail;
2045
2046 if (volume_info->nodfs) {
2047 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2048 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2049 }
2050 tcon->seal = volume_info->seal;
2051 /* we can have only one retry value for a connection
2052 to a share so for resources mounted more than once
2053 to the same server share the last value passed in
2054 for the retry flag is used */
2055 tcon->retry = volume_info->retry;
2056 tcon->nocase = volume_info->nocase;
2057 tcon->local_lease = volume_info->local_lease;
2058
2059 spin_lock(&cifs_tcp_ses_lock);
2060 list_add(&tcon->tcon_list, &ses->tcon_list);
2061 spin_unlock(&cifs_tcp_ses_lock);
2062
2063 cifs_fscache_get_super_cookie(tcon);
2064
2065 return tcon;
2066
2067 out_fail:
2068 tconInfoFree(tcon);
2069 return ERR_PTR(rc);
2070 }
2071
2072 void
2073 cifs_put_tlink(struct tcon_link *tlink)
2074 {
2075 if (!tlink || IS_ERR(tlink))
2076 return;
2077
2078 if (!atomic_dec_and_test(&tlink->tl_count) ||
2079 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2080 tlink->tl_time = jiffies;
2081 return;
2082 }
2083
2084 if (!IS_ERR(tlink_tcon(tlink)))
2085 cifs_put_tcon(tlink_tcon(tlink));
2086 kfree(tlink);
2087 return;
2088 }
2089
2090 int
2091 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2092 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2093 struct dfs_info3_param **preferrals, int remap)
2094 {
2095 char *temp_unc;
2096 int rc = 0;
2097
2098 *pnum_referrals = 0;
2099 *preferrals = NULL;
2100
2101 if (pSesInfo->ipc_tid == 0) {
2102 temp_unc = kmalloc(2 /* for slashes */ +
2103 strnlen(pSesInfo->serverName,
2104 SERVER_NAME_LEN_WITH_NULL * 2)
2105 + 1 + 4 /* slash IPC$ */ + 2,
2106 GFP_KERNEL);
2107 if (temp_unc == NULL)
2108 return -ENOMEM;
2109 temp_unc[0] = '\\';
2110 temp_unc[1] = '\\';
2111 strcpy(temp_unc + 2, pSesInfo->serverName);
2112 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2113 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2114 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2115 kfree(temp_unc);
2116 }
2117 if (rc == 0)
2118 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2119 pnum_referrals, nls_codepage, remap);
2120 /* BB map targetUNCs to dfs_info3 structures, here or
2121 in CIFSGetDFSRefer BB */
2122
2123 return rc;
2124 }
2125
2126 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2127 static struct lock_class_key cifs_key[2];
2128 static struct lock_class_key cifs_slock_key[2];
2129
2130 static inline void
2131 cifs_reclassify_socket4(struct socket *sock)
2132 {
2133 struct sock *sk = sock->sk;
2134 BUG_ON(sock_owned_by_user(sk));
2135 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2136 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2137 }
2138
2139 static inline void
2140 cifs_reclassify_socket6(struct socket *sock)
2141 {
2142 struct sock *sk = sock->sk;
2143 BUG_ON(sock_owned_by_user(sk));
2144 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2145 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2146 }
2147 #else
2148 static inline void
2149 cifs_reclassify_socket4(struct socket *sock)
2150 {
2151 }
2152
2153 static inline void
2154 cifs_reclassify_socket6(struct socket *sock)
2155 {
2156 }
2157 #endif
2158
2159 /* See RFC1001 section 14 on representation of Netbios names */
2160 static void rfc1002mangle(char *target, char *source, unsigned int length)
2161 {
2162 unsigned int i, j;
2163
2164 for (i = 0, j = 0; i < (length); i++) {
2165 /* mask a nibble at a time and encode */
2166 target[j] = 'A' + (0x0F & (source[i] >> 4));
2167 target[j+1] = 'A' + (0x0F & source[i]);
2168 j += 2;
2169 }
2170
2171 }
2172
2173 static int
2174 bind_socket(struct TCP_Server_Info *server)
2175 {
2176 int rc = 0;
2177 if (server->srcaddr.ss_family != AF_UNSPEC) {
2178 /* Bind to the specified local IP address */
2179 struct socket *socket = server->ssocket;
2180 rc = socket->ops->bind(socket,
2181 (struct sockaddr *) &server->srcaddr,
2182 sizeof(server->srcaddr));
2183 if (rc < 0) {
2184 struct sockaddr_in *saddr4;
2185 struct sockaddr_in6 *saddr6;
2186 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2187 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2188 if (saddr6->sin6_family == AF_INET6)
2189 cERROR(1, "cifs: "
2190 "Failed to bind to: %pI6c, error: %d\n",
2191 &saddr6->sin6_addr, rc);
2192 else
2193 cERROR(1, "cifs: "
2194 "Failed to bind to: %pI4, error: %d\n",
2195 &saddr4->sin_addr.s_addr, rc);
2196 }
2197 }
2198 return rc;
2199 }
2200
2201 static int
2202 ip_rfc1001_connect(struct TCP_Server_Info *server)
2203 {
2204 int rc = 0;
2205 /*
2206 * some servers require RFC1001 sessinit before sending
2207 * negprot - BB check reconnection in case where second
2208 * sessinit is sent but no second negprot
2209 */
2210 struct rfc1002_session_packet *ses_init_buf;
2211 struct smb_hdr *smb_buf;
2212 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2213 GFP_KERNEL);
2214 if (ses_init_buf) {
2215 ses_init_buf->trailer.session_req.called_len = 32;
2216
2217 if (server->server_RFC1001_name &&
2218 server->server_RFC1001_name[0] != 0)
2219 rfc1002mangle(ses_init_buf->trailer.
2220 session_req.called_name,
2221 server->server_RFC1001_name,
2222 RFC1001_NAME_LEN_WITH_NULL);
2223 else
2224 rfc1002mangle(ses_init_buf->trailer.
2225 session_req.called_name,
2226 DEFAULT_CIFS_CALLED_NAME,
2227 RFC1001_NAME_LEN_WITH_NULL);
2228
2229 ses_init_buf->trailer.session_req.calling_len = 32;
2230
2231 /*
2232 * calling name ends in null (byte 16) from old smb
2233 * convention.
2234 */
2235 if (server->workstation_RFC1001_name &&
2236 server->workstation_RFC1001_name[0] != 0)
2237 rfc1002mangle(ses_init_buf->trailer.
2238 session_req.calling_name,
2239 server->workstation_RFC1001_name,
2240 RFC1001_NAME_LEN_WITH_NULL);
2241 else
2242 rfc1002mangle(ses_init_buf->trailer.
2243 session_req.calling_name,
2244 "LINUX_CIFS_CLNT",
2245 RFC1001_NAME_LEN_WITH_NULL);
2246
2247 ses_init_buf->trailer.session_req.scope1 = 0;
2248 ses_init_buf->trailer.session_req.scope2 = 0;
2249 smb_buf = (struct smb_hdr *)ses_init_buf;
2250
2251 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2252 smb_buf->smb_buf_length = 0x81000044;
2253 rc = smb_send(server, smb_buf, 0x44);
2254 kfree(ses_init_buf);
2255 /*
2256 * RFC1001 layer in at least one server
2257 * requires very short break before negprot
2258 * presumably because not expecting negprot
2259 * to follow so fast. This is a simple
2260 * solution that works without
2261 * complicating the code and causes no
2262 * significant slowing down on mount
2263 * for everyone else
2264 */
2265 usleep_range(1000, 2000);
2266 }
2267 /*
2268 * else the negprot may still work without this
2269 * even though malloc failed
2270 */
2271
2272 return rc;
2273 }
2274
2275 static int
2276 generic_ip_connect(struct TCP_Server_Info *server)
2277 {
2278 int rc = 0;
2279 unsigned short int sport;
2280 int slen, sfamily;
2281 struct socket *socket = server->ssocket;
2282 struct sockaddr *saddr;
2283
2284 saddr = (struct sockaddr *) &server->dstaddr;
2285
2286 if (server->dstaddr.ss_family == AF_INET6) {
2287 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2288 slen = sizeof(struct sockaddr_in6);
2289 sfamily = AF_INET6;
2290 } else {
2291 sport = ((struct sockaddr_in *) saddr)->sin_port;
2292 slen = sizeof(struct sockaddr_in);
2293 sfamily = AF_INET;
2294 }
2295
2296 if (socket == NULL) {
2297 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2298 IPPROTO_TCP, &socket, 1);
2299 if (rc < 0) {
2300 cERROR(1, "Error %d creating socket", rc);
2301 server->ssocket = NULL;
2302 return rc;
2303 }
2304
2305 /* BB other socket options to set KEEPALIVE, NODELAY? */
2306 cFYI(1, "Socket created");
2307 server->ssocket = socket;
2308 socket->sk->sk_allocation = GFP_NOFS;
2309 if (sfamily == AF_INET6)
2310 cifs_reclassify_socket6(socket);
2311 else
2312 cifs_reclassify_socket4(socket);
2313 }
2314
2315 rc = bind_socket(server);
2316 if (rc < 0)
2317 return rc;
2318
2319 rc = socket->ops->connect(socket, saddr, slen, 0);
2320 if (rc < 0) {
2321 cFYI(1, "Error %d connecting to server", rc);
2322 sock_release(socket);
2323 server->ssocket = NULL;
2324 return rc;
2325 }
2326
2327 /*
2328 * Eventually check for other socket options to change from
2329 * the default. sock_setsockopt not used because it expects
2330 * user space buffer
2331 */
2332 socket->sk->sk_rcvtimeo = 7 * HZ;
2333 socket->sk->sk_sndtimeo = 5 * HZ;
2334
2335 /* make the bufsizes depend on wsize/rsize and max requests */
2336 if (server->noautotune) {
2337 if (socket->sk->sk_sndbuf < (200 * 1024))
2338 socket->sk->sk_sndbuf = 200 * 1024;
2339 if (socket->sk->sk_rcvbuf < (140 * 1024))
2340 socket->sk->sk_rcvbuf = 140 * 1024;
2341 }
2342
2343 if (server->tcp_nodelay) {
2344 int val = 1;
2345 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2346 (char *)&val, sizeof(val));
2347 if (rc)
2348 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2349 }
2350
2351 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2352 socket->sk->sk_sndbuf,
2353 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2354
2355 if (sport == htons(RFC1001_PORT))
2356 rc = ip_rfc1001_connect(server);
2357
2358 return rc;
2359 }
2360
2361 static int
2362 ip_connect(struct TCP_Server_Info *server)
2363 {
2364 unsigned short int *sport;
2365 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2366 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2367
2368 if (server->dstaddr.ss_family == AF_INET6)
2369 sport = &addr6->sin6_port;
2370 else
2371 sport = &addr->sin_port;
2372
2373 if (*sport == 0) {
2374 int rc;
2375
2376 /* try with 445 port at first */
2377 *sport = htons(CIFS_PORT);
2378
2379 rc = generic_ip_connect(server);
2380 if (rc >= 0)
2381 return rc;
2382
2383 /* if it failed, try with 139 port */
2384 *sport = htons(RFC1001_PORT);
2385 }
2386
2387 return generic_ip_connect(server);
2388 }
2389
2390 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2391 struct super_block *sb, struct smb_vol *vol_info)
2392 {
2393 /* if we are reconnecting then should we check to see if
2394 * any requested capabilities changed locally e.g. via
2395 * remount but we can not do much about it here
2396 * if they have (even if we could detect it by the following)
2397 * Perhaps we could add a backpointer to array of sb from tcon
2398 * or if we change to make all sb to same share the same
2399 * sb as NFS - then we only have one backpointer to sb.
2400 * What if we wanted to mount the server share twice once with
2401 * and once without posixacls or posix paths? */
2402 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2403
2404 if (vol_info && vol_info->no_linux_ext) {
2405 tcon->fsUnixInfo.Capability = 0;
2406 tcon->unix_ext = 0; /* Unix Extensions disabled */
2407 cFYI(1, "Linux protocol extensions disabled");
2408 return;
2409 } else if (vol_info)
2410 tcon->unix_ext = 1; /* Unix Extensions supported */
2411
2412 if (tcon->unix_ext == 0) {
2413 cFYI(1, "Unix extensions disabled so not set on reconnect");
2414 return;
2415 }
2416
2417 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2418 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2419
2420 /* check for reconnect case in which we do not
2421 want to change the mount behavior if we can avoid it */
2422 if (vol_info == NULL) {
2423 /* turn off POSIX ACL and PATHNAMES if not set
2424 originally at mount time */
2425 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2426 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2427 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2428 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2429 cERROR(1, "POSIXPATH support change");
2430 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2431 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2432 cERROR(1, "possible reconnect error");
2433 cERROR(1, "server disabled POSIX path support");
2434 }
2435 }
2436
2437 cap &= CIFS_UNIX_CAP_MASK;
2438 if (vol_info && vol_info->no_psx_acl)
2439 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2440 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2441 cFYI(1, "negotiated posix acl support");
2442 if (sb)
2443 sb->s_flags |= MS_POSIXACL;
2444 }
2445
2446 if (vol_info && vol_info->posix_paths == 0)
2447 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2448 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2449 cFYI(1, "negotiate posix pathnames");
2450 if (sb)
2451 CIFS_SB(sb)->mnt_cifs_flags |=
2452 CIFS_MOUNT_POSIX_PATHS;
2453 }
2454
2455 /* We might be setting the path sep back to a different
2456 form if we are reconnecting and the server switched its
2457 posix path capability for this share */
2458 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2459 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2460
2461 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2462 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2463 CIFS_SB(sb)->rsize = 127 * 1024;
2464 cFYI(DBG2, "larger reads not supported by srv");
2465 }
2466 }
2467
2468
2469 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2470 #ifdef CONFIG_CIFS_DEBUG2
2471 if (cap & CIFS_UNIX_FCNTL_CAP)
2472 cFYI(1, "FCNTL cap");
2473 if (cap & CIFS_UNIX_EXTATTR_CAP)
2474 cFYI(1, "EXTATTR cap");
2475 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2476 cFYI(1, "POSIX path cap");
2477 if (cap & CIFS_UNIX_XATTR_CAP)
2478 cFYI(1, "XATTR cap");
2479 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2480 cFYI(1, "POSIX ACL cap");
2481 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2482 cFYI(1, "very large read cap");
2483 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2484 cFYI(1, "very large write cap");
2485 #endif /* CIFS_DEBUG2 */
2486 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2487 if (vol_info == NULL) {
2488 cFYI(1, "resetting capabilities failed");
2489 } else
2490 cERROR(1, "Negotiating Unix capabilities "
2491 "with the server failed. Consider "
2492 "mounting with the Unix Extensions\n"
2493 "disabled, if problems are found, "
2494 "by specifying the nounix mount "
2495 "option.");
2496
2497 }
2498 }
2499 }
2500
2501 static void
2502 convert_delimiter(char *path, char delim)
2503 {
2504 int i;
2505 char old_delim;
2506
2507 if (path == NULL)
2508 return;
2509
2510 if (delim == '/')
2511 old_delim = '\\';
2512 else
2513 old_delim = '/';
2514
2515 for (i = 0; path[i] != '\0'; i++) {
2516 if (path[i] == old_delim)
2517 path[i] = delim;
2518 }
2519 }
2520
2521 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2522 struct cifs_sb_info *cifs_sb)
2523 {
2524 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2525
2526 if (pvolume_info->rsize > CIFSMaxBufSize) {
2527 cERROR(1, "rsize %d too large, using MaxBufSize",
2528 pvolume_info->rsize);
2529 cifs_sb->rsize = CIFSMaxBufSize;
2530 } else if ((pvolume_info->rsize) &&
2531 (pvolume_info->rsize <= CIFSMaxBufSize))
2532 cifs_sb->rsize = pvolume_info->rsize;
2533 else /* default */
2534 cifs_sb->rsize = CIFSMaxBufSize;
2535
2536 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2537 cERROR(1, "wsize %d too large, using 4096 instead",
2538 pvolume_info->wsize);
2539 cifs_sb->wsize = 4096;
2540 } else if (pvolume_info->wsize)
2541 cifs_sb->wsize = pvolume_info->wsize;
2542 else
2543 cifs_sb->wsize = min_t(const int,
2544 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2545 127*1024);
2546 /* old default of CIFSMaxBufSize was too small now
2547 that SMB Write2 can send multiple pages in kvec.
2548 RFC1001 does not describe what happens when frame
2549 bigger than 128K is sent so use that as max in
2550 conjunction with 52K kvec constraint on arch with 4K
2551 page size */
2552
2553 if (cifs_sb->rsize < 2048) {
2554 cifs_sb->rsize = 2048;
2555 /* Windows ME may prefer this */
2556 cFYI(1, "readsize set to minimum: 2048");
2557 }
2558 /* calculate prepath */
2559 cifs_sb->prepath = pvolume_info->prepath;
2560 if (cifs_sb->prepath) {
2561 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2562 /* we can not convert the / to \ in the path
2563 separators in the prefixpath yet because we do not
2564 know (until reset_cifs_unix_caps is called later)
2565 whether POSIX PATH CAP is available. We normalize
2566 the / to \ after reset_cifs_unix_caps is called */
2567 pvolume_info->prepath = NULL;
2568 } else
2569 cifs_sb->prepathlen = 0;
2570 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2571 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2572 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2573 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2574 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2575 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2576
2577 cifs_sb->actimeo = pvolume_info->actimeo;
2578
2579 if (pvolume_info->noperm)
2580 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2581 if (pvolume_info->setuids)
2582 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2583 if (pvolume_info->server_ino)
2584 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2585 if (pvolume_info->remap)
2586 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2587 if (pvolume_info->no_xattr)
2588 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2589 if (pvolume_info->sfu_emul)
2590 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2591 if (pvolume_info->nobrl)
2592 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2593 if (pvolume_info->nostrictsync)
2594 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2595 if (pvolume_info->mand_lock)
2596 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2597 if (pvolume_info->cifs_acl)
2598 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2599 if (pvolume_info->override_uid)
2600 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2601 if (pvolume_info->override_gid)
2602 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2603 if (pvolume_info->dynperm)
2604 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2605 if (pvolume_info->fsc)
2606 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2607 if (pvolume_info->multiuser)
2608 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2609 CIFS_MOUNT_NO_PERM);
2610 if (pvolume_info->strict_io)
2611 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2612 if (pvolume_info->direct_io) {
2613 cFYI(1, "mounting share using direct i/o");
2614 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2615 }
2616 if (pvolume_info->mfsymlinks) {
2617 if (pvolume_info->sfu_emul) {
2618 cERROR(1, "mount option mfsymlinks ignored if sfu "
2619 "mount option is used");
2620 } else {
2621 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2622 }
2623 }
2624
2625 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2626 cERROR(1, "mount option dynperm ignored if cifsacl "
2627 "mount option supported");
2628 }
2629
2630 static int
2631 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2632 struct cifs_sb_info *cifs_sb, const char *full_path)
2633 {
2634 int rc;
2635 FILE_ALL_INFO *pfile_info;
2636
2637 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2638 if (pfile_info == NULL)
2639 return -ENOMEM;
2640
2641 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2642 0 /* not legacy */, cifs_sb->local_nls,
2643 cifs_sb->mnt_cifs_flags &
2644 CIFS_MOUNT_MAP_SPECIAL_CHR);
2645 kfree(pfile_info);
2646 return rc;
2647 }
2648
2649 static void
2650 cleanup_volume_info(struct smb_vol **pvolume_info)
2651 {
2652 struct smb_vol *volume_info;
2653
2654 if (!pvolume_info || !*pvolume_info)
2655 return;
2656
2657 volume_info = *pvolume_info;
2658 kzfree(volume_info->password);
2659 kfree(volume_info->UNC);
2660 kfree(volume_info->prepath);
2661 kfree(volume_info);
2662 *pvolume_info = NULL;
2663 return;
2664 }
2665
2666 #ifdef CONFIG_CIFS_DFS_UPCALL
2667 /* build_path_to_root returns full path to root when
2668 * we do not have an exiting connection (tcon) */
2669 static char *
2670 build_unc_path_to_root(const struct smb_vol *volume_info,
2671 const struct cifs_sb_info *cifs_sb)
2672 {
2673 char *full_path;
2674
2675 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2676 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2677 if (full_path == NULL)
2678 return ERR_PTR(-ENOMEM);
2679
2680 strncpy(full_path, volume_info->UNC, unc_len);
2681 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2682 int i;
2683 for (i = 0; i < unc_len; i++) {
2684 if (full_path[i] == '\\')
2685 full_path[i] = '/';
2686 }
2687 }
2688
2689 if (cifs_sb->prepathlen)
2690 strncpy(full_path + unc_len, cifs_sb->prepath,
2691 cifs_sb->prepathlen);
2692
2693 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2694 return full_path;
2695 }
2696 #endif
2697
2698 int
2699 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2700 char *mount_data_global, const char *devname)
2701 {
2702 int rc;
2703 int xid;
2704 struct smb_vol *volume_info;
2705 struct cifsSesInfo *pSesInfo;
2706 struct cifsTconInfo *tcon;
2707 struct TCP_Server_Info *srvTcp;
2708 char *full_path;
2709 char *mount_data = mount_data_global;
2710 struct tcon_link *tlink;
2711 #ifdef CONFIG_CIFS_DFS_UPCALL
2712 struct dfs_info3_param *referrals = NULL;
2713 unsigned int num_referrals = 0;
2714 int referral_walks_count = 0;
2715 try_mount_again:
2716 #endif
2717 rc = 0;
2718 tcon = NULL;
2719 pSesInfo = NULL;
2720 srvTcp = NULL;
2721 full_path = NULL;
2722 tlink = NULL;
2723
2724 xid = GetXid();
2725
2726 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2727 if (!volume_info) {
2728 rc = -ENOMEM;
2729 goto out;
2730 }
2731
2732 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2733 rc = -EINVAL;
2734 goto out;
2735 }
2736
2737 if (volume_info->nullauth) {
2738 cFYI(1, "null user");
2739 volume_info->username = "";
2740 } else if (volume_info->username) {
2741 /* BB fixme parse for domain name here */
2742 cFYI(1, "Username: %s", volume_info->username);
2743 } else {
2744 cifserror("No username specified");
2745 /* In userspace mount helper we can get user name from alternate
2746 locations such as env variables and files on disk */
2747 rc = -EINVAL;
2748 goto out;
2749 }
2750
2751 /* this is needed for ASCII cp to Unicode converts */
2752 if (volume_info->iocharset == NULL) {
2753 /* load_nls_default cannot return null */
2754 volume_info->local_nls = load_nls_default();
2755 } else {
2756 volume_info->local_nls = load_nls(volume_info->iocharset);
2757 if (volume_info->local_nls == NULL) {
2758 cERROR(1, "CIFS mount error: iocharset %s not found",
2759 volume_info->iocharset);
2760 rc = -ELIBACC;
2761 goto out;
2762 }
2763 }
2764 cifs_sb->local_nls = volume_info->local_nls;
2765
2766 /* get a reference to a tcp session */
2767 srvTcp = cifs_get_tcp_session(volume_info);
2768 if (IS_ERR(srvTcp)) {
2769 rc = PTR_ERR(srvTcp);
2770 goto out;
2771 }
2772
2773 /* get a reference to a SMB session */
2774 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2775 if (IS_ERR(pSesInfo)) {
2776 rc = PTR_ERR(pSesInfo);
2777 pSesInfo = NULL;
2778 goto mount_fail_check;
2779 }
2780
2781 setup_cifs_sb(volume_info, cifs_sb);
2782 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2783 sb->s_maxbytes = MAX_LFS_FILESIZE;
2784 else
2785 sb->s_maxbytes = MAX_NON_LFS;
2786
2787 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2788 sb->s_time_gran = 100;
2789
2790 /* search for existing tcon to this server share */
2791 tcon = cifs_get_tcon(pSesInfo, volume_info);
2792 if (IS_ERR(tcon)) {
2793 rc = PTR_ERR(tcon);
2794 tcon = NULL;
2795 goto remote_path_check;
2796 }
2797
2798 /* do not care if following two calls succeed - informational */
2799 if (!tcon->ipc) {
2800 CIFSSMBQFSDeviceInfo(xid, tcon);
2801 CIFSSMBQFSAttributeInfo(xid, tcon);
2802 }
2803
2804 /* tell server which Unix caps we support */
2805 if (tcon->ses->capabilities & CAP_UNIX)
2806 /* reset of caps checks mount to see if unix extensions
2807 disabled for just this mount */
2808 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2809 else
2810 tcon->unix_ext = 0; /* server does not support them */
2811
2812 /* convert forward to back slashes in prepath here if needed */
2813 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2814 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2815
2816 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2817 cifs_sb->rsize = 1024 * 127;
2818 cFYI(DBG2, "no very large read support, rsize now 127K");
2819 }
2820 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2821 cifs_sb->wsize = min(cifs_sb->wsize,
2822 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2823 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2824 cifs_sb->rsize = min(cifs_sb->rsize,
2825 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2826
2827 remote_path_check:
2828 /* check if a whole path (including prepath) is not remote */
2829 if (!rc && cifs_sb->prepathlen && tcon) {
2830 /* build_path_to_root works only when we have a valid tcon */
2831 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2832 if (full_path == NULL) {
2833 rc = -ENOMEM;
2834 goto mount_fail_check;
2835 }
2836 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2837 if (rc != 0 && rc != -EREMOTE) {
2838 kfree(full_path);
2839 goto mount_fail_check;
2840 }
2841 kfree(full_path);
2842 }
2843
2844 /* get referral if needed */
2845 if (rc == -EREMOTE) {
2846 #ifdef CONFIG_CIFS_DFS_UPCALL
2847 if (referral_walks_count > MAX_NESTED_LINKS) {
2848 /*
2849 * BB: when we implement proper loop detection,
2850 * we will remove this check. But now we need it
2851 * to prevent an indefinite loop if 'DFS tree' is
2852 * misconfigured (i.e. has loops).
2853 */
2854 rc = -ELOOP;
2855 goto mount_fail_check;
2856 }
2857 /* convert forward to back slashes in prepath here if needed */
2858 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2859 convert_delimiter(cifs_sb->prepath,
2860 CIFS_DIR_SEP(cifs_sb));
2861 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2862 if (IS_ERR(full_path)) {
2863 rc = PTR_ERR(full_path);
2864 goto mount_fail_check;
2865 }
2866
2867 cFYI(1, "Getting referral for: %s", full_path);
2868 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2869 cifs_sb->local_nls, &num_referrals, &referrals,
2870 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2871 if (!rc && num_referrals > 0) {
2872 char *fake_devname = NULL;
2873
2874 if (mount_data != mount_data_global)
2875 kfree(mount_data);
2876
2877 mount_data = cifs_compose_mount_options(
2878 cifs_sb->mountdata, full_path + 1,
2879 referrals, &fake_devname);
2880
2881 free_dfs_info_array(referrals, num_referrals);
2882 kfree(fake_devname);
2883 kfree(full_path);
2884
2885 if (IS_ERR(mount_data)) {
2886 rc = PTR_ERR(mount_data);
2887 mount_data = NULL;
2888 goto mount_fail_check;
2889 }
2890
2891 if (tcon)
2892 cifs_put_tcon(tcon);
2893 else if (pSesInfo)
2894 cifs_put_smb_ses(pSesInfo);
2895
2896 cleanup_volume_info(&volume_info);
2897 referral_walks_count++;
2898 FreeXid(xid);
2899 goto try_mount_again;
2900 }
2901 #else /* No DFS support, return error on mount */
2902 rc = -EOPNOTSUPP;
2903 #endif
2904 }
2905
2906 if (rc)
2907 goto mount_fail_check;
2908
2909 /* now, hang the tcon off of the superblock */
2910 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2911 if (tlink == NULL) {
2912 rc = -ENOMEM;
2913 goto mount_fail_check;
2914 }
2915
2916 tlink->tl_uid = pSesInfo->linux_uid;
2917 tlink->tl_tcon = tcon;
2918 tlink->tl_time = jiffies;
2919 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2920 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2921
2922 cifs_sb->master_tlink = tlink;
2923 spin_lock(&cifs_sb->tlink_tree_lock);
2924 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2925 spin_unlock(&cifs_sb->tlink_tree_lock);
2926
2927 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2928 TLINK_IDLE_EXPIRE);
2929
2930 mount_fail_check:
2931 /* on error free sesinfo and tcon struct if needed */
2932 if (rc) {
2933 if (mount_data != mount_data_global)
2934 kfree(mount_data);
2935 /* If find_unc succeeded then rc == 0 so we can not end */
2936 /* up accidently freeing someone elses tcon struct */
2937 if (tcon)
2938 cifs_put_tcon(tcon);
2939 else if (pSesInfo)
2940 cifs_put_smb_ses(pSesInfo);
2941 else
2942 cifs_put_tcp_session(srvTcp);
2943 goto out;
2944 }
2945
2946 /* volume_info->password is freed above when existing session found
2947 (in which case it is not needed anymore) but when new sesion is created
2948 the password ptr is put in the new session structure (in which case the
2949 password will be freed at unmount time) */
2950 out:
2951 /* zero out password before freeing */
2952 cleanup_volume_info(&volume_info);
2953 FreeXid(xid);
2954 return rc;
2955 }
2956
2957 int
2958 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2959 const char *tree, struct cifsTconInfo *tcon,
2960 const struct nls_table *nls_codepage)
2961 {
2962 struct smb_hdr *smb_buffer;
2963 struct smb_hdr *smb_buffer_response;
2964 TCONX_REQ *pSMB;
2965 TCONX_RSP *pSMBr;
2966 unsigned char *bcc_ptr;
2967 int rc = 0;
2968 int length;
2969 __u16 bytes_left, count;
2970
2971 if (ses == NULL)
2972 return -EIO;
2973
2974 smb_buffer = cifs_buf_get();
2975 if (smb_buffer == NULL)
2976 return -ENOMEM;
2977
2978 smb_buffer_response = smb_buffer;
2979
2980 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2981 NULL /*no tid */ , 4 /*wct */ );
2982
2983 smb_buffer->Mid = GetNextMid(ses->server);
2984 smb_buffer->Uid = ses->Suid;
2985 pSMB = (TCONX_REQ *) smb_buffer;
2986 pSMBr = (TCONX_RSP *) smb_buffer_response;
2987
2988 pSMB->AndXCommand = 0xFF;
2989 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2990 bcc_ptr = &pSMB->Password[0];
2991 if ((ses->server->secMode) & SECMODE_USER) {
2992 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
2993 *bcc_ptr = 0; /* password is null byte */
2994 bcc_ptr++; /* skip password */
2995 /* already aligned so no need to do it below */
2996 } else {
2997 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
2998 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2999 specified as required (when that support is added to
3000 the vfs in the future) as only NTLM or the much
3001 weaker LANMAN (which we do not send by default) is accepted
3002 by Samba (not sure whether other servers allow
3003 NTLMv2 password here) */
3004 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3005 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3006 (ses->server->secType == LANMAN))
3007 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3008 ses->server->secMode &
3009 SECMODE_PW_ENCRYPT ? true : false,
3010 bcc_ptr);
3011 else
3012 #endif /* CIFS_WEAK_PW_HASH */
3013 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3014 bcc_ptr);
3015
3016 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3017 if (ses->capabilities & CAP_UNICODE) {
3018 /* must align unicode strings */
3019 *bcc_ptr = 0; /* null byte password */
3020 bcc_ptr++;
3021 }
3022 }
3023
3024 if (ses->server->secMode &
3025 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3026 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3027
3028 if (ses->capabilities & CAP_STATUS32) {
3029 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3030 }
3031 if (ses->capabilities & CAP_DFS) {
3032 smb_buffer->Flags2 |= SMBFLG2_DFS;
3033 }
3034 if (ses->capabilities & CAP_UNICODE) {
3035 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3036 length =
3037 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3038 6 /* max utf8 char length in bytes */ *
3039 (/* server len*/ + 256 /* share len */), nls_codepage);
3040 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3041 bcc_ptr += 2; /* skip trailing null */
3042 } else { /* ASCII */
3043 strcpy(bcc_ptr, tree);
3044 bcc_ptr += strlen(tree) + 1;
3045 }
3046 strcpy(bcc_ptr, "?????");
3047 bcc_ptr += strlen("?????");
3048 bcc_ptr += 1;
3049 count = bcc_ptr - &pSMB->Password[0];
3050 pSMB->hdr.smb_buf_length += count;
3051 pSMB->ByteCount = cpu_to_le16(count);
3052
3053 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3054 0);
3055
3056 /* above now done in SendReceive */
3057 if ((rc == 0) && (tcon != NULL)) {
3058 bool is_unicode;
3059
3060 tcon->tidStatus = CifsGood;
3061 tcon->need_reconnect = false;
3062 tcon->tid = smb_buffer_response->Tid;
3063 bcc_ptr = pByteArea(smb_buffer_response);
3064 bytes_left = get_bcc(smb_buffer_response);
3065 length = strnlen(bcc_ptr, bytes_left - 2);
3066 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3067 is_unicode = true;
3068 else
3069 is_unicode = false;
3070
3071
3072 /* skip service field (NB: this field is always ASCII) */
3073 if (length == 3) {
3074 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3075 (bcc_ptr[2] == 'C')) {
3076 cFYI(1, "IPC connection");
3077 tcon->ipc = 1;
3078 }
3079 } else if (length == 2) {
3080 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3081 /* the most common case */
3082 cFYI(1, "disk share connection");
3083 }
3084 }
3085 bcc_ptr += length + 1;
3086 bytes_left -= (length + 1);
3087 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3088
3089 /* mostly informational -- no need to fail on error here */
3090 kfree(tcon->nativeFileSystem);
3091 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3092 bytes_left, is_unicode,
3093 nls_codepage);
3094
3095 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3096
3097 if ((smb_buffer_response->WordCount == 3) ||
3098 (smb_buffer_response->WordCount == 7))
3099 /* field is in same location */
3100 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3101 else
3102 tcon->Flags = 0;
3103 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3104 } else if ((rc == 0) && tcon == NULL) {
3105 /* all we need to save for IPC$ connection */
3106 ses->ipc_tid = smb_buffer_response->Tid;
3107 }
3108
3109 cifs_buf_release(smb_buffer);
3110 return rc;
3111 }
3112
3113 int
3114 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3115 {
3116 struct rb_root *root = &cifs_sb->tlink_tree;
3117 struct rb_node *node;
3118 struct tcon_link *tlink;
3119 char *tmp;
3120
3121 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3122
3123 spin_lock(&cifs_sb->tlink_tree_lock);
3124 while ((node = rb_first(root))) {
3125 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3126 cifs_get_tlink(tlink);
3127 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3128 rb_erase(node, root);
3129
3130 spin_unlock(&cifs_sb->tlink_tree_lock);
3131 cifs_put_tlink(tlink);
3132 spin_lock(&cifs_sb->tlink_tree_lock);
3133 }
3134 spin_unlock(&cifs_sb->tlink_tree_lock);
3135
3136 tmp = cifs_sb->prepath;
3137 cifs_sb->prepathlen = 0;
3138 cifs_sb->prepath = NULL;
3139 kfree(tmp);
3140
3141 return 0;
3142 }
3143
3144 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3145 {
3146 int rc = 0;
3147 struct TCP_Server_Info *server = ses->server;
3148
3149 /* only send once per connect */
3150 if (server->maxBuf != 0)
3151 return 0;
3152
3153 rc = CIFSSMBNegotiate(xid, ses);
3154 if (rc == -EAGAIN) {
3155 /* retry only once on 1st time connection */
3156 rc = CIFSSMBNegotiate(xid, ses);
3157 if (rc == -EAGAIN)
3158 rc = -EHOSTDOWN;
3159 }
3160 if (rc == 0) {
3161 spin_lock(&GlobalMid_Lock);
3162 if (server->tcpStatus != CifsExiting)
3163 server->tcpStatus = CifsGood;
3164 else
3165 rc = -EHOSTDOWN;
3166 spin_unlock(&GlobalMid_Lock);
3167
3168 }
3169
3170 return rc;
3171 }
3172
3173
3174 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3175 struct nls_table *nls_info)
3176 {
3177 int rc = 0;
3178 struct TCP_Server_Info *server = ses->server;
3179
3180 ses->flags = 0;
3181 ses->capabilities = server->capabilities;
3182 if (linuxExtEnabled == 0)
3183 ses->capabilities &= (~CAP_UNIX);
3184
3185 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3186 server->secMode, server->capabilities, server->timeAdj);
3187
3188 rc = CIFS_SessSetup(xid, ses, nls_info);
3189 if (rc) {
3190 cERROR(1, "Send error in SessSetup = %d", rc);
3191 } else {
3192 mutex_lock(&ses->server->srv_mutex);
3193 if (!server->session_estab) {
3194 server->session_key.response = ses->auth_key.response;
3195 server->session_key.len = ses->auth_key.len;
3196 server->sequence_number = 0x2;
3197 server->session_estab = true;
3198 ses->auth_key.response = NULL;
3199 }
3200 mutex_unlock(&server->srv_mutex);
3201
3202 cFYI(1, "CIFS Session Established successfully");
3203 spin_lock(&GlobalMid_Lock);
3204 ses->status = CifsGood;
3205 ses->need_reconnect = false;
3206 spin_unlock(&GlobalMid_Lock);
3207 }
3208
3209 kfree(ses->auth_key.response);
3210 ses->auth_key.response = NULL;
3211 ses->auth_key.len = 0;
3212 kfree(ses->ntlmssp);
3213 ses->ntlmssp = NULL;
3214
3215 return rc;
3216 }
3217
3218 static struct cifsTconInfo *
3219 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3220 {
3221 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3222 struct cifsSesInfo *ses;
3223 struct cifsTconInfo *tcon = NULL;
3224 struct smb_vol *vol_info;
3225 char username[MAX_USERNAME_SIZE + 1];
3226
3227 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3228 if (vol_info == NULL) {
3229 tcon = ERR_PTR(-ENOMEM);
3230 goto out;
3231 }
3232
3233 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3234 vol_info->username = username;
3235 vol_info->local_nls = cifs_sb->local_nls;
3236 vol_info->linux_uid = fsuid;
3237 vol_info->cred_uid = fsuid;
3238 vol_info->UNC = master_tcon->treeName;
3239 vol_info->retry = master_tcon->retry;
3240 vol_info->nocase = master_tcon->nocase;
3241 vol_info->local_lease = master_tcon->local_lease;
3242 vol_info->no_linux_ext = !master_tcon->unix_ext;
3243
3244 /* FIXME: allow for other secFlg settings */
3245 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3246
3247 /* get a reference for the same TCP session */
3248 spin_lock(&cifs_tcp_ses_lock);
3249 ++master_tcon->ses->server->srv_count;
3250 spin_unlock(&cifs_tcp_ses_lock);
3251
3252 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3253 if (IS_ERR(ses)) {
3254 tcon = (struct cifsTconInfo *)ses;
3255 cifs_put_tcp_session(master_tcon->ses->server);
3256 goto out;
3257 }
3258
3259 tcon = cifs_get_tcon(ses, vol_info);
3260 if (IS_ERR(tcon)) {
3261 cifs_put_smb_ses(ses);
3262 goto out;
3263 }
3264
3265 if (ses->capabilities & CAP_UNIX)
3266 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3267 out:
3268 kfree(vol_info);
3269
3270 return tcon;
3271 }
3272
3273 static inline struct tcon_link *
3274 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3275 {
3276 return cifs_sb->master_tlink;
3277 }
3278
3279 struct cifsTconInfo *
3280 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3281 {
3282 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3283 }
3284
3285 static int
3286 cifs_sb_tcon_pending_wait(void *unused)
3287 {
3288 schedule();
3289 return signal_pending(current) ? -ERESTARTSYS : 0;
3290 }
3291
3292 /* find and return a tlink with given uid */
3293 static struct tcon_link *
3294 tlink_rb_search(struct rb_root *root, uid_t uid)
3295 {
3296 struct rb_node *node = root->rb_node;
3297 struct tcon_link *tlink;
3298
3299 while (node) {
3300 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3301
3302 if (tlink->tl_uid > uid)
3303 node = node->rb_left;
3304 else if (tlink->tl_uid < uid)
3305 node = node->rb_right;
3306 else
3307 return tlink;
3308 }
3309 return NULL;
3310 }
3311
3312 /* insert a tcon_link into the tree */
3313 static void
3314 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3315 {
3316 struct rb_node **new = &(root->rb_node), *parent = NULL;
3317 struct tcon_link *tlink;
3318
3319 while (*new) {
3320 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3321 parent = *new;
3322
3323 if (tlink->tl_uid > new_tlink->tl_uid)
3324 new = &((*new)->rb_left);
3325 else
3326 new = &((*new)->rb_right);
3327 }
3328
3329 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3330 rb_insert_color(&new_tlink->tl_rbnode, root);
3331 }
3332
3333 /*
3334 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3335 * current task.
3336 *
3337 * If the superblock doesn't refer to a multiuser mount, then just return
3338 * the master tcon for the mount.
3339 *
3340 * First, search the rbtree for an existing tcon for this fsuid. If one
3341 * exists, then check to see if it's pending construction. If it is then wait
3342 * for construction to complete. Once it's no longer pending, check to see if
3343 * it failed and either return an error or retry construction, depending on
3344 * the timeout.
3345 *
3346 * If one doesn't exist then insert a new tcon_link struct into the tree and
3347 * try to construct a new one.
3348 */
3349 struct tcon_link *
3350 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3351 {
3352 int ret;
3353 uid_t fsuid = current_fsuid();
3354 struct tcon_link *tlink, *newtlink;
3355
3356 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3357 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3358
3359 spin_lock(&cifs_sb->tlink_tree_lock);
3360 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3361 if (tlink)
3362 cifs_get_tlink(tlink);
3363 spin_unlock(&cifs_sb->tlink_tree_lock);
3364
3365 if (tlink == NULL) {
3366 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3367 if (newtlink == NULL)
3368 return ERR_PTR(-ENOMEM);
3369 newtlink->tl_uid = fsuid;
3370 newtlink->tl_tcon = ERR_PTR(-EACCES);
3371 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3372 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3373 cifs_get_tlink(newtlink);
3374
3375 spin_lock(&cifs_sb->tlink_tree_lock);
3376 /* was one inserted after previous search? */
3377 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3378 if (tlink) {
3379 cifs_get_tlink(tlink);
3380 spin_unlock(&cifs_sb->tlink_tree_lock);
3381 kfree(newtlink);
3382 goto wait_for_construction;
3383 }
3384 tlink = newtlink;
3385 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3386 spin_unlock(&cifs_sb->tlink_tree_lock);
3387 } else {
3388 wait_for_construction:
3389 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3390 cifs_sb_tcon_pending_wait,
3391 TASK_INTERRUPTIBLE);
3392 if (ret) {
3393 cifs_put_tlink(tlink);
3394 return ERR_PTR(ret);
3395 }
3396
3397 /* if it's good, return it */
3398 if (!IS_ERR(tlink->tl_tcon))
3399 return tlink;
3400
3401 /* return error if we tried this already recently */
3402 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3403 cifs_put_tlink(tlink);
3404 return ERR_PTR(-EACCES);
3405 }
3406
3407 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3408 goto wait_for_construction;
3409 }
3410
3411 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3412 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3413 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3414
3415 if (IS_ERR(tlink->tl_tcon)) {
3416 cifs_put_tlink(tlink);
3417 return ERR_PTR(-EACCES);
3418 }
3419
3420 return tlink;
3421 }
3422
3423 /*
3424 * periodic workqueue job that scans tcon_tree for a superblock and closes
3425 * out tcons.
3426 */
3427 static void
3428 cifs_prune_tlinks(struct work_struct *work)
3429 {
3430 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3431 prune_tlinks.work);
3432 struct rb_root *root = &cifs_sb->tlink_tree;
3433 struct rb_node *node = rb_first(root);
3434 struct rb_node *tmp;
3435 struct tcon_link *tlink;
3436
3437 /*
3438 * Because we drop the spinlock in the loop in order to put the tlink
3439 * it's not guarded against removal of links from the tree. The only
3440 * places that remove entries from the tree are this function and
3441 * umounts. Because this function is non-reentrant and is canceled
3442 * before umount can proceed, this is safe.
3443 */
3444 spin_lock(&cifs_sb->tlink_tree_lock);
3445 node = rb_first(root);
3446 while (node != NULL) {
3447 tmp = node;
3448 node = rb_next(tmp);
3449 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3450
3451 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3452 atomic_read(&tlink->tl_count) != 0 ||
3453 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3454 continue;
3455
3456 cifs_get_tlink(tlink);
3457 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3458 rb_erase(tmp, root);
3459
3460 spin_unlock(&cifs_sb->tlink_tree_lock);
3461 cifs_put_tlink(tlink);
3462 spin_lock(&cifs_sb->tlink_tree_lock);
3463 }
3464 spin_unlock(&cifs_sb->tlink_tree_lock);
3465
3466 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3467 TLINK_IDLE_EXPIRE);
3468 }
kernel source for telekom puls (alcatel/mediatek)