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