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