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