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