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