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