4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.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 <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 extern void SMBNTencrypt(unsigned char *passwd
, unsigned char *c8
,
55 extern mempool_t
*cifs_req_poolp
;
63 char *in6_addr
; /* ipv6 address as human readable form of in6_addr */
64 char *iocharset
; /* local code page for mapping to and from Unicode */
65 char source_rfc1001_name
[16]; /* netbios name of client */
66 char target_rfc1001_name
[16]; /* netbios name of server for Win9x/ME */
79 bool no_psx_acl
:1; /* set if posix acl support should be disabled */
81 bool no_xattr
:1; /* set if xattr (EA) support should be disabled*/
82 bool server_ino
:1; /* use inode numbers from server ie UniqueId */
84 bool remap
:1; /* set to remap seven reserved chars in filenames */
85 bool posix_paths
:1; /* unset to not ask for posix pathnames. */
88 bool nullauth
:1; /* attempt to authenticate with null user */
89 unsigned nocase
; /* request case insensitive filenames */
90 unsigned nobrl
; /* disable sending byte range locks to srv */
94 unsigned short int port
;
98 static int ipv4_connect(struct sockaddr_in
*psin_server
,
99 struct socket
**csocket
,
101 char *server_netb_name
);
102 static int ipv6_connect(struct sockaddr_in6
*psin_server
,
103 struct socket
**csocket
);
107 * cifs tcp session reconnection
109 * mark tcp session as reconnecting so temporarily locked
110 * mark all smb sessions as reconnecting for tcp session
111 * reconnect tcp session
112 * wake up waiters on reconnection? - (not needed currently)
116 cifs_reconnect(struct TCP_Server_Info
*server
)
119 struct list_head
*tmp
;
120 struct cifsSesInfo
*ses
;
121 struct cifsTconInfo
*tcon
;
122 struct mid_q_entry
*mid_entry
;
124 spin_lock(&GlobalMid_Lock
);
125 if (kthread_should_stop()) {
126 /* the demux thread will exit normally
127 next time through the loop */
128 spin_unlock(&GlobalMid_Lock
);
131 server
->tcpStatus
= CifsNeedReconnect
;
132 spin_unlock(&GlobalMid_Lock
);
135 cFYI(1, ("Reconnecting tcp session"));
137 /* before reconnecting the tcp session, mark the smb session (uid)
138 and the tid bad so they are not used until reconnected */
139 read_lock(&GlobalSMBSeslock
);
140 list_for_each(tmp
, &GlobalSMBSessionList
) {
141 ses
= list_entry(tmp
, struct cifsSesInfo
, cifsSessionList
);
143 if (ses
->server
== server
) {
144 ses
->status
= CifsNeedReconnect
;
148 /* else tcp and smb sessions need reconnection */
150 list_for_each(tmp
, &GlobalTreeConnectionList
) {
151 tcon
= list_entry(tmp
, struct cifsTconInfo
, cifsConnectionList
);
152 if ((tcon
) && (tcon
->ses
) && (tcon
->ses
->server
== server
))
153 tcon
->tidStatus
= CifsNeedReconnect
;
155 read_unlock(&GlobalSMBSeslock
);
156 /* do not want to be sending data on a socket we are freeing */
157 down(&server
->tcpSem
);
158 if (server
->ssocket
) {
159 cFYI(1, ("State: 0x%x Flags: 0x%lx", server
->ssocket
->state
,
160 server
->ssocket
->flags
));
161 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
162 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
163 server
->ssocket
->state
,
164 server
->ssocket
->flags
));
165 sock_release(server
->ssocket
);
166 server
->ssocket
= NULL
;
169 spin_lock(&GlobalMid_Lock
);
170 list_for_each(tmp
, &server
->pending_mid_q
) {
171 mid_entry
= list_entry(tmp
, struct
175 if (mid_entry
->midState
== MID_REQUEST_SUBMITTED
) {
176 /* Mark other intransit requests as needing
177 retry so we do not immediately mark the
178 session bad again (ie after we reconnect
179 below) as they timeout too */
180 mid_entry
->midState
= MID_RETRY_NEEDED
;
184 spin_unlock(&GlobalMid_Lock
);
187 while ((!kthread_should_stop()) && (server
->tcpStatus
!= CifsGood
)) {
189 if (server
->protocolType
== IPV6
) {
190 rc
= ipv6_connect(&server
->addr
.sockAddr6
,
193 rc
= ipv4_connect(&server
->addr
.sockAddr
,
195 server
->workstation_RFC1001_name
,
196 server
->server_RFC1001_name
);
199 cFYI(1, ("reconnect error %d", rc
));
202 atomic_inc(&tcpSesReconnectCount
);
203 spin_lock(&GlobalMid_Lock
);
204 if (!kthread_should_stop())
205 server
->tcpStatus
= CifsGood
;
206 server
->sequence_number
= 0;
207 spin_unlock(&GlobalMid_Lock
);
208 /* atomic_set(&server->inFlight,0);*/
209 wake_up(&server
->response_q
);
217 0 not a transact2, or all data present
218 >0 transact2 with that much data missing
219 -EINVAL = invalid transact2
222 static int check2ndT2(struct smb_hdr
*pSMB
, unsigned int maxBufSize
)
224 struct smb_t2_rsp
*pSMBt
;
226 int data_in_this_rsp
;
229 if (pSMB
->Command
!= SMB_COM_TRANSACTION2
)
232 /* check for plausible wct, bcc and t2 data and parm sizes */
233 /* check for parm and data offset going beyond end of smb */
234 if (pSMB
->WordCount
!= 10) { /* coalesce_t2 depends on this */
235 cFYI(1, ("invalid transact2 word count"));
239 pSMBt
= (struct smb_t2_rsp
*)pSMB
;
241 total_data_size
= le16_to_cpu(pSMBt
->t2_rsp
.TotalDataCount
);
242 data_in_this_rsp
= le16_to_cpu(pSMBt
->t2_rsp
.DataCount
);
244 remaining
= total_data_size
- data_in_this_rsp
;
248 else if (remaining
< 0) {
249 cFYI(1, ("total data %d smaller than data in frame %d",
250 total_data_size
, data_in_this_rsp
));
253 cFYI(1, ("missing %d bytes from transact2, check next response",
255 if (total_data_size
> maxBufSize
) {
256 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
257 total_data_size
, maxBufSize
));
264 static int coalesce_t2(struct smb_hdr
*psecond
, struct smb_hdr
*pTargetSMB
)
266 struct smb_t2_rsp
*pSMB2
= (struct smb_t2_rsp
*)psecond
;
267 struct smb_t2_rsp
*pSMBt
= (struct smb_t2_rsp
*)pTargetSMB
;
272 char *data_area_of_target
;
273 char *data_area_of_buf2
;
276 total_data_size
= le16_to_cpu(pSMBt
->t2_rsp
.TotalDataCount
);
278 if (total_data_size
!= le16_to_cpu(pSMB2
->t2_rsp
.TotalDataCount
)) {
279 cFYI(1, ("total data size of primary and secondary t2 differ"));
282 total_in_buf
= le16_to_cpu(pSMBt
->t2_rsp
.DataCount
);
284 remaining
= total_data_size
- total_in_buf
;
289 if (remaining
== 0) /* nothing to do, ignore */
292 total_in_buf2
= le16_to_cpu(pSMB2
->t2_rsp
.DataCount
);
293 if (remaining
< total_in_buf2
) {
294 cFYI(1, ("transact2 2nd response contains too much data"));
297 /* find end of first SMB data area */
298 data_area_of_target
= (char *)&pSMBt
->hdr
.Protocol
+
299 le16_to_cpu(pSMBt
->t2_rsp
.DataOffset
);
300 /* validate target area */
302 data_area_of_buf2
= (char *) &pSMB2
->hdr
.Protocol
+
303 le16_to_cpu(pSMB2
->t2_rsp
.DataOffset
);
305 data_area_of_target
+= total_in_buf
;
307 /* copy second buffer into end of first buffer */
308 memcpy(data_area_of_target
, data_area_of_buf2
, total_in_buf2
);
309 total_in_buf
+= total_in_buf2
;
310 pSMBt
->t2_rsp
.DataCount
= cpu_to_le16(total_in_buf
);
311 byte_count
= le16_to_cpu(BCC_LE(pTargetSMB
));
312 byte_count
+= total_in_buf2
;
313 BCC_LE(pTargetSMB
) = cpu_to_le16(byte_count
);
315 byte_count
= pTargetSMB
->smb_buf_length
;
316 byte_count
+= total_in_buf2
;
318 /* BB also add check that we are not beyond maximum buffer size */
320 pTargetSMB
->smb_buf_length
= byte_count
;
322 if (remaining
== total_in_buf2
) {
323 cFYI(1, ("found the last secondary response"));
324 return 0; /* we are done */
325 } else /* more responses to go */
331 cifs_demultiplex_thread(struct TCP_Server_Info
*server
)
334 unsigned int pdu_length
, total_read
;
335 struct smb_hdr
*smb_buffer
= NULL
;
336 struct smb_hdr
*bigbuf
= NULL
;
337 struct smb_hdr
*smallbuf
= NULL
;
338 struct msghdr smb_msg
;
340 struct socket
*csocket
= server
->ssocket
;
341 struct list_head
*tmp
;
342 struct cifsSesInfo
*ses
;
343 struct task_struct
*task_to_wake
= NULL
;
344 struct mid_q_entry
*mid_entry
;
346 bool isLargeBuf
= false;
350 current
->flags
|= PF_MEMALLOC
;
351 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current
)));
352 write_lock(&GlobalSMBSeslock
);
353 atomic_inc(&tcpSesAllocCount
);
354 length
= tcpSesAllocCount
.counter
;
355 write_unlock(&GlobalSMBSeslock
);
357 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
361 while (!kthread_should_stop()) {
364 if (bigbuf
== NULL
) {
365 bigbuf
= cifs_buf_get();
367 cERROR(1, ("No memory for large SMB response"));
369 /* retry will check if exiting */
372 } else if (isLargeBuf
) {
373 /* we are reusing a dirty large buf, clear its start */
374 memset(bigbuf
, 0, sizeof(struct smb_hdr
));
377 if (smallbuf
== NULL
) {
378 smallbuf
= cifs_small_buf_get();
380 cERROR(1, ("No memory for SMB response"));
382 /* retry will check if exiting */
385 /* beginning of smb buffer is cleared in our buf_get */
386 } else /* if existing small buf clear beginning */
387 memset(smallbuf
, 0, sizeof(struct smb_hdr
));
391 smb_buffer
= smallbuf
;
392 iov
.iov_base
= smb_buffer
;
394 smb_msg
.msg_control
= NULL
;
395 smb_msg
.msg_controllen
= 0;
396 pdu_length
= 4; /* enough to get RFC1001 header */
399 kernel_recvmsg(csocket
, &smb_msg
,
400 &iov
, 1, pdu_length
, 0 /* BB other flags? */);
402 if (kthread_should_stop()) {
404 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
405 cFYI(1, ("Reconnect after server stopped responding"));
406 cifs_reconnect(server
);
407 cFYI(1, ("call to reconnect done"));
408 csocket
= server
->ssocket
;
410 } else if ((length
== -ERESTARTSYS
) || (length
== -EAGAIN
)) {
411 msleep(1); /* minimum sleep to prevent looping
412 allowing socket to clear and app threads to set
413 tcpStatus CifsNeedReconnect if server hung */
418 } else if (length
<= 0) {
419 if (server
->tcpStatus
== CifsNew
) {
420 cFYI(1, ("tcp session abend after SMBnegprot"));
421 /* some servers kill the TCP session rather than
422 returning an SMB negprot error, in which
423 case reconnecting here is not going to help,
424 and so simply return error to mount */
427 if (!try_to_freeze() && (length
== -EINTR
)) {
428 cFYI(1, ("cifsd thread killed"));
431 cFYI(1, ("Reconnect after unexpected peek error %d",
433 cifs_reconnect(server
);
434 csocket
= server
->ssocket
;
435 wake_up(&server
->response_q
);
437 } else if (length
< pdu_length
) {
438 cFYI(1, ("requested %d bytes but only got %d bytes",
439 pdu_length
, length
));
440 pdu_length
-= length
;
445 /* The right amount was read from socket - 4 bytes */
446 /* so we can now interpret the length field */
448 /* the first byte big endian of the length field,
449 is actually not part of the length but the type
450 with the most common, zero, as regular data */
451 temp
= *((char *) smb_buffer
);
453 /* Note that FC 1001 length is big endian on the wire,
454 but we convert it here so it is always manipulated
455 as host byte order */
456 pdu_length
= ntohl(smb_buffer
->smb_buf_length
);
457 smb_buffer
->smb_buf_length
= pdu_length
;
459 cFYI(1, ("rfc1002 length 0x%x", pdu_length
+4));
461 if (temp
== (char) RFC1002_SESSION_KEEP_ALIVE
) {
463 } else if (temp
== (char)RFC1002_POSITIVE_SESSION_RESPONSE
) {
464 cFYI(1, ("Good RFC 1002 session rsp"));
466 } else if (temp
== (char)RFC1002_NEGATIVE_SESSION_RESPONSE
) {
467 /* we get this from Windows 98 instead of
468 an error on SMB negprot response */
469 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
471 if (server
->tcpStatus
== CifsNew
) {
472 /* if nack on negprot (rather than
473 ret of smb negprot error) reconnecting
474 not going to help, ret error to mount */
477 /* give server a second to
478 clean up before reconnect attempt */
480 /* always try 445 first on reconnect
481 since we get NACK on some if we ever
482 connected to port 139 (the NACK is
483 since we do not begin with RFC1001
484 session initialize frame) */
485 server
->addr
.sockAddr
.sin_port
=
487 cifs_reconnect(server
);
488 csocket
= server
->ssocket
;
489 wake_up(&server
->response_q
);
492 } else if (temp
!= (char) 0) {
493 cERROR(1, ("Unknown RFC 1002 frame"));
494 cifs_dump_mem(" Received Data: ", (char *)smb_buffer
,
496 cifs_reconnect(server
);
497 csocket
= server
->ssocket
;
501 /* else we have an SMB response */
502 if ((pdu_length
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
- 4) ||
503 (pdu_length
< sizeof(struct smb_hdr
) - 1 - 4)) {
504 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
505 length
, pdu_length
+4));
506 cifs_reconnect(server
);
507 csocket
= server
->ssocket
;
508 wake_up(&server
->response_q
);
515 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
517 memcpy(bigbuf
, smallbuf
, 4);
521 iov
.iov_base
= 4 + (char *)smb_buffer
;
522 iov
.iov_len
= pdu_length
;
523 for (total_read
= 0; total_read
< pdu_length
;
524 total_read
+= length
) {
525 length
= kernel_recvmsg(csocket
, &smb_msg
, &iov
, 1,
526 pdu_length
- total_read
, 0);
527 if (kthread_should_stop() ||
528 (length
== -EINTR
)) {
532 } else if (server
->tcpStatus
== CifsNeedReconnect
) {
533 cifs_reconnect(server
);
534 csocket
= server
->ssocket
;
535 /* Reconnect wakes up rspns q */
536 /* Now we will reread sock */
539 } else if ((length
== -ERESTARTSYS
) ||
540 (length
== -EAGAIN
)) {
541 msleep(1); /* minimum sleep to prevent looping,
542 allowing socket to clear and app
543 threads to set tcpStatus
544 CifsNeedReconnect if server hung*/
547 } else if (length
<= 0) {
548 cERROR(1, ("Received no data, expecting %d",
549 pdu_length
- total_read
));
550 cifs_reconnect(server
);
551 csocket
= server
->ssocket
;
558 else if (reconnect
== 1)
561 length
+= 4; /* account for rfc1002 hdr */
564 dump_smb(smb_buffer
, length
);
565 if (checkSMB(smb_buffer
, smb_buffer
->Mid
, total_read
+4)) {
566 cifs_dump_mem("Bad SMB: ", smb_buffer
, 48);
572 spin_lock(&GlobalMid_Lock
);
573 list_for_each(tmp
, &server
->pending_mid_q
) {
574 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
576 if ((mid_entry
->mid
== smb_buffer
->Mid
) &&
577 (mid_entry
->midState
== MID_REQUEST_SUBMITTED
) &&
578 (mid_entry
->command
== smb_buffer
->Command
)) {
579 if (check2ndT2(smb_buffer
,server
->maxBuf
) > 0) {
580 /* We have a multipart transact2 resp */
582 if (mid_entry
->resp_buf
) {
583 /* merge response - fix up 1st*/
584 if (coalesce_t2(smb_buffer
,
585 mid_entry
->resp_buf
)) {
586 mid_entry
->multiRsp
=
590 /* all parts received */
591 mid_entry
->multiEnd
=
597 cERROR(1,("1st trans2 resp needs bigbuf"));
598 /* BB maybe we can fix this up, switch
599 to already allocated large buffer? */
601 /* Have first buffer */
602 mid_entry
->resp_buf
=
604 mid_entry
->largeBuf
=
611 mid_entry
->resp_buf
= smb_buffer
;
612 mid_entry
->largeBuf
= isLargeBuf
;
614 task_to_wake
= mid_entry
->tsk
;
615 mid_entry
->midState
= MID_RESPONSE_RECEIVED
;
616 #ifdef CONFIG_CIFS_STATS2
617 mid_entry
->when_received
= jiffies
;
619 /* so we do not time out requests to server
620 which is still responding (since server could
621 be busy but not dead) */
622 server
->lstrp
= jiffies
;
626 spin_unlock(&GlobalMid_Lock
);
628 /* Was previous buf put in mpx struct for multi-rsp? */
630 /* smb buffer will be freed by user thread */
636 wake_up_process(task_to_wake
);
637 } else if (!is_valid_oplock_break(smb_buffer
, server
) &&
639 cERROR(1, ("No task to wake, unknown frame received! "
640 "NumMids %d", midCount
.counter
));
641 cifs_dump_mem("Received Data is: ", (char *)smb_buffer
,
642 sizeof(struct smb_hdr
));
643 #ifdef CONFIG_CIFS_DEBUG2
644 cifs_dump_detail(smb_buffer
);
645 cifs_dump_mids(server
);
646 #endif /* CIFS_DEBUG2 */
649 } /* end while !EXITING */
651 spin_lock(&GlobalMid_Lock
);
652 server
->tcpStatus
= CifsExiting
;
653 spin_unlock(&GlobalMid_Lock
);
655 /* don't exit until kthread_stop is called */
656 set_current_state(TASK_UNINTERRUPTIBLE
);
657 while (!kthread_should_stop()) {
659 set_current_state(TASK_UNINTERRUPTIBLE
);
661 set_current_state(TASK_RUNNING
);
663 /* check if we have blocked requests that need to free */
664 /* Note that cifs_max_pending is normally 50, but
665 can be set at module install time to as little as two */
666 spin_lock(&GlobalMid_Lock
);
667 if (atomic_read(&server
->inFlight
) >= cifs_max_pending
)
668 atomic_set(&server
->inFlight
, cifs_max_pending
- 1);
669 /* We do not want to set the max_pending too low or we
670 could end up with the counter going negative */
671 spin_unlock(&GlobalMid_Lock
);
672 /* Although there should not be any requests blocked on
673 this queue it can not hurt to be paranoid and try to wake up requests
674 that may haven been blocked when more than 50 at time were on the wire
675 to the same server - they now will see the session is in exit state
676 and get out of SendReceive. */
677 wake_up_all(&server
->request_q
);
678 /* give those requests time to exit */
681 if (server
->ssocket
) {
682 sock_release(csocket
);
683 server
->ssocket
= NULL
;
685 /* buffer usuallly freed in free_mid - need to free it here on exit */
686 cifs_buf_release(bigbuf
);
687 if (smallbuf
) /* no sense logging a debug message if NULL */
688 cifs_small_buf_release(smallbuf
);
690 read_lock(&GlobalSMBSeslock
);
691 if (list_empty(&server
->pending_mid_q
)) {
692 /* loop through server session structures attached to this and
694 list_for_each(tmp
, &GlobalSMBSessionList
) {
696 list_entry(tmp
, struct cifsSesInfo
,
698 if (ses
->server
== server
) {
699 ses
->status
= CifsExiting
;
703 read_unlock(&GlobalSMBSeslock
);
705 /* although we can not zero the server struct pointer yet,
706 since there are active requests which may depnd on them,
707 mark the corresponding SMB sessions as exiting too */
708 list_for_each(tmp
, &GlobalSMBSessionList
) {
709 ses
= list_entry(tmp
, struct cifsSesInfo
,
711 if (ses
->server
== server
)
712 ses
->status
= CifsExiting
;
715 spin_lock(&GlobalMid_Lock
);
716 list_for_each(tmp
, &server
->pending_mid_q
) {
717 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
718 if (mid_entry
->midState
== MID_REQUEST_SUBMITTED
) {
719 cFYI(1, ("Clearing Mid 0x%x - waking up ",
721 task_to_wake
= mid_entry
->tsk
;
723 wake_up_process(task_to_wake
);
726 spin_unlock(&GlobalMid_Lock
);
727 read_unlock(&GlobalSMBSeslock
);
728 /* 1/8th of sec is more than enough time for them to exit */
732 if (!list_empty(&server
->pending_mid_q
)) {
733 /* mpx threads have not exited yet give them
734 at least the smb send timeout time for long ops */
735 /* due to delays on oplock break requests, we need
736 to wait at least 45 seconds before giving up
737 on a request getting a response and going ahead
739 cFYI(1, ("Wait for exit from demultiplex thread"));
741 /* if threads still have not exited they are probably never
742 coming home not much else we can do but free the memory */
745 write_lock(&GlobalSMBSeslock
);
746 atomic_dec(&tcpSesAllocCount
);
747 length
= tcpSesAllocCount
.counter
;
749 /* last chance to mark ses pointers invalid
750 if there are any pointing to this (e.g
751 if a crazy root user tried to kill cifsd
752 kernel thread explicitly this might happen) */
753 list_for_each(tmp
, &GlobalSMBSessionList
) {
754 ses
= list_entry(tmp
, struct cifsSesInfo
,
756 if (ses
->server
== server
)
759 write_unlock(&GlobalSMBSeslock
);
761 kfree(server
->hostname
);
764 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
,
770 /* extract the host portion of the UNC string */
772 extract_hostname(const char *unc
)
778 /* skip double chars at beginning of string */
779 /* BB: check validity of these bytes? */
782 /* delimiter between hostname and sharename is always '\\' now */
783 delim
= strchr(src
, '\\');
785 return ERR_PTR(-EINVAL
);
788 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
790 return ERR_PTR(-ENOMEM
);
792 memcpy(dst
, src
, len
);
799 cifs_parse_mount_options(char *options
, const char *devname
,
804 unsigned int temp_len
, i
, j
;
810 if (Local_System_Name
[0] != 0)
811 memcpy(vol
->source_rfc1001_name
, Local_System_Name
, 15);
813 char *nodename
= utsname()->nodename
;
814 int n
= strnlen(nodename
, 15);
815 memset(vol
->source_rfc1001_name
, 0x20, 15);
816 for (i
= 0; i
< n
; i
++) {
817 /* does not have to be perfect mapping since field is
818 informational, only used for servers that do not support
819 port 445 and it can be overridden at mount time */
820 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
823 vol
->source_rfc1001_name
[15] = 0;
824 /* null target name indicates to use *SMBSERVR default called name
825 if we end up sending RFC1001 session initialize */
826 vol
->target_rfc1001_name
[0] = 0;
827 vol
->linux_uid
= current
->uid
; /* current->euid instead? */
828 vol
->linux_gid
= current
->gid
;
829 vol
->dir_mode
= S_IRWXUGO
;
830 /* 2767 perms indicate mandatory locking support */
831 vol
->file_mode
= (S_IRWXUGO
| S_ISGID
) & (~S_IXGRP
);
833 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
835 /* default is always to request posix paths. */
836 vol
->posix_paths
= 1;
841 if (strncmp(options
, "sep=", 4) == 0) {
842 if (options
[4] != 0) {
843 separator
[0] = options
[4];
846 cFYI(1, ("Null separator not allowed"));
850 while ((data
= strsep(&options
, separator
)) != NULL
) {
853 if ((value
= strchr(data
, '=')) != NULL
)
856 /* Have to parse this before we parse for "user" */
857 if (strnicmp(data
, "user_xattr", 10) == 0) {
859 } else if (strnicmp(data
, "nouser_xattr", 12) == 0) {
861 } else if (strnicmp(data
, "user", 4) == 0) {
864 "CIFS: invalid or missing username\n");
865 return 1; /* needs_arg; */
866 } else if (!*value
) {
867 /* null user, ie anonymous, authentication */
870 if (strnlen(value
, 200) < 200) {
871 vol
->username
= value
;
873 printk(KERN_WARNING
"CIFS: username too long\n");
876 } else if (strnicmp(data
, "pass", 4) == 0) {
878 vol
->password
= NULL
;
880 } else if (value
[0] == 0) {
881 /* check if string begins with double comma
882 since that would mean the password really
883 does start with a comma, and would not
884 indicate an empty string */
885 if (value
[1] != separator
[0]) {
886 vol
->password
= NULL
;
890 temp_len
= strlen(value
);
891 /* removed password length check, NTLM passwords
892 can be arbitrarily long */
894 /* if comma in password, the string will be
895 prematurely null terminated. Commas in password are
896 specified across the cifs mount interface by a double
897 comma ie ,, and a comma used as in other cases ie ','
898 as a parameter delimiter/separator is single and due
899 to the strsep above is temporarily zeroed. */
901 /* NB: password legally can have multiple commas and
902 the only illegal character in a password is null */
904 if ((value
[temp_len
] == 0) &&
905 (value
[temp_len
+1] == separator
[0])) {
907 value
[temp_len
] = separator
[0];
908 temp_len
+= 2; /* move after second comma */
909 while (value
[temp_len
] != 0) {
910 if (value
[temp_len
] == separator
[0]) {
911 if (value
[temp_len
+1] ==
913 /* skip second comma */
916 /* single comma indicating start
923 if (value
[temp_len
] == 0) {
927 /* point option to start of next parm */
928 options
= value
+ temp_len
+ 1;
930 /* go from value to value + temp_len condensing
931 double commas to singles. Note that this ends up
932 allocating a few bytes too many, which is ok */
933 vol
->password
= kzalloc(temp_len
, GFP_KERNEL
);
934 if (vol
->password
== NULL
) {
935 printk(KERN_WARNING
"CIFS: no memory "
939 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
940 vol
->password
[j
] = value
[i
];
941 if (value
[i
] == separator
[0]
942 && value
[i
+1] == separator
[0]) {
943 /* skip second comma */
947 vol
->password
[j
] = 0;
949 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
950 if (vol
->password
== NULL
) {
951 printk(KERN_WARNING
"CIFS: no memory "
955 strcpy(vol
->password
, value
);
957 } else if (strnicmp(data
, "ip", 2) == 0) {
958 if (!value
|| !*value
) {
960 } else if (strnlen(value
, 35) < 35) {
963 printk(KERN_WARNING
"CIFS: ip address "
967 } else if (strnicmp(data
, "sec", 3) == 0) {
968 if (!value
|| !*value
) {
969 cERROR(1, ("no security value specified"));
971 } else if (strnicmp(value
, "krb5i", 5) == 0) {
972 vol
->secFlg
|= CIFSSEC_MAY_KRB5
|
974 } else if (strnicmp(value
, "krb5p", 5) == 0) {
975 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
977 cERROR(1, ("Krb5 cifs privacy not supported"));
979 } else if (strnicmp(value
, "krb5", 4) == 0) {
980 vol
->secFlg
|= CIFSSEC_MAY_KRB5
;
981 } else if (strnicmp(value
, "ntlmv2i", 7) == 0) {
982 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
|
984 } else if (strnicmp(value
, "ntlmv2", 6) == 0) {
985 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
986 } else if (strnicmp(value
, "ntlmi", 5) == 0) {
987 vol
->secFlg
|= CIFSSEC_MAY_NTLM
|
989 } else if (strnicmp(value
, "ntlm", 4) == 0) {
990 /* ntlm is default so can be turned off too */
991 vol
->secFlg
|= CIFSSEC_MAY_NTLM
;
992 } else if (strnicmp(value
, "nontlm", 6) == 0) {
993 /* BB is there a better way to do this? */
994 vol
->secFlg
|= CIFSSEC_MAY_NTLMV2
;
995 #ifdef CONFIG_CIFS_WEAK_PW_HASH
996 } else if (strnicmp(value
, "lanman", 6) == 0) {
997 vol
->secFlg
|= CIFSSEC_MAY_LANMAN
;
999 } else if (strnicmp(value
, "none", 4) == 0) {
1002 cERROR(1, ("bad security option: %s", value
));
1005 } else if ((strnicmp(data
, "unc", 3) == 0)
1006 || (strnicmp(data
, "target", 6) == 0)
1007 || (strnicmp(data
, "path", 4) == 0)) {
1008 if (!value
|| !*value
) {
1009 printk(KERN_WARNING
"CIFS: invalid path to "
1010 "network resource\n");
1011 return 1; /* needs_arg; */
1013 if ((temp_len
= strnlen(value
, 300)) < 300) {
1014 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1015 if (vol
->UNC
== NULL
)
1017 strcpy(vol
->UNC
, value
);
1018 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1021 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1023 "CIFS: UNC Path does not begin "
1024 "with // or \\\\ \n");
1028 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1031 } else if ((strnicmp(data
, "domain", 3) == 0)
1032 || (strnicmp(data
, "workgroup", 5) == 0)) {
1033 if (!value
|| !*value
) {
1034 printk(KERN_WARNING
"CIFS: invalid domain name\n");
1035 return 1; /* needs_arg; */
1037 /* BB are there cases in which a comma can be valid in
1038 a domain name and need special handling? */
1039 if (strnlen(value
, 256) < 256) {
1040 vol
->domainname
= value
;
1041 cFYI(1, ("Domain name set"));
1043 printk(KERN_WARNING
"CIFS: domain name too "
1047 } else if (strnicmp(data
, "prefixpath", 10) == 0) {
1048 if (!value
|| !*value
) {
1050 "CIFS: invalid path prefix\n");
1051 return 1; /* needs_argument */
1053 if ((temp_len
= strnlen(value
, 1024)) < 1024) {
1054 if (value
[0] != '/')
1055 temp_len
++; /* missing leading slash */
1056 vol
->prepath
= kmalloc(temp_len
+1, GFP_KERNEL
);
1057 if (vol
->prepath
== NULL
)
1059 if (value
[0] != '/') {
1060 vol
->prepath
[0] = '/';
1061 strcpy(vol
->prepath
+1, value
);
1063 strcpy(vol
->prepath
, value
);
1064 cFYI(1, ("prefix path %s", vol
->prepath
));
1066 printk(KERN_WARNING
"CIFS: prefix too long\n");
1069 } else if (strnicmp(data
, "iocharset", 9) == 0) {
1070 if (!value
|| !*value
) {
1071 printk(KERN_WARNING
"CIFS: invalid iocharset "
1073 return 1; /* needs_arg; */
1075 if (strnlen(value
, 65) < 65) {
1076 if (strnicmp(value
, "default", 7))
1077 vol
->iocharset
= value
;
1078 /* if iocharset not set then load_nls_default
1079 is used by caller */
1080 cFYI(1, ("iocharset set to %s", value
));
1082 printk(KERN_WARNING
"CIFS: iocharset name "
1086 } else if (strnicmp(data
, "uid", 3) == 0) {
1087 if (value
&& *value
) {
1089 simple_strtoul(value
, &value
, 0);
1090 vol
->override_uid
= 1;
1092 } else if (strnicmp(data
, "gid", 3) == 0) {
1093 if (value
&& *value
) {
1095 simple_strtoul(value
, &value
, 0);
1096 vol
->override_gid
= 1;
1098 } else if (strnicmp(data
, "file_mode", 4) == 0) {
1099 if (value
&& *value
) {
1101 simple_strtoul(value
, &value
, 0);
1103 } else if (strnicmp(data
, "dir_mode", 4) == 0) {
1104 if (value
&& *value
) {
1106 simple_strtoul(value
, &value
, 0);
1108 } else if (strnicmp(data
, "dirmode", 4) == 0) {
1109 if (value
&& *value
) {
1111 simple_strtoul(value
, &value
, 0);
1113 } else if (strnicmp(data
, "port", 4) == 0) {
1114 if (value
&& *value
) {
1116 simple_strtoul(value
, &value
, 0);
1118 } else if (strnicmp(data
, "rsize", 5) == 0) {
1119 if (value
&& *value
) {
1121 simple_strtoul(value
, &value
, 0);
1123 } else if (strnicmp(data
, "wsize", 5) == 0) {
1124 if (value
&& *value
) {
1126 simple_strtoul(value
, &value
, 0);
1128 } else if (strnicmp(data
, "sockopt", 5) == 0) {
1129 if (value
&& *value
) {
1131 simple_strtoul(value
, &value
, 0);
1133 } else if (strnicmp(data
, "netbiosname", 4) == 0) {
1134 if (!value
|| !*value
|| (*value
== ' ')) {
1135 cFYI(1, ("invalid (empty) netbiosname"));
1137 memset(vol
->source_rfc1001_name
, 0x20, 15);
1138 for (i
= 0; i
< 15; i
++) {
1139 /* BB are there cases in which a comma can be
1140 valid in this workstation netbios name (and need
1141 special handling)? */
1143 /* We do not uppercase netbiosname for user */
1147 vol
->source_rfc1001_name
[i
] =
1150 /* The string has 16th byte zero still from
1151 set at top of the function */
1152 if ((i
== 15) && (value
[i
] != 0))
1153 printk(KERN_WARNING
"CIFS: netbiosname"
1154 " longer than 15 truncated.\n");
1156 } else if (strnicmp(data
, "servern", 7) == 0) {
1157 /* servernetbiosname specified override *SMBSERVER */
1158 if (!value
|| !*value
|| (*value
== ' ')) {
1159 cFYI(1, ("empty server netbiosname specified"));
1161 /* last byte, type, is 0x20 for servr type */
1162 memset(vol
->target_rfc1001_name
, 0x20, 16);
1164 for (i
= 0; i
< 15; i
++) {
1165 /* BB are there cases in which a comma can be
1166 valid in this workstation netbios name
1167 (and need special handling)? */
1169 /* user or mount helper must uppercase
1174 vol
->target_rfc1001_name
[i
] =
1177 /* The string has 16th byte zero still from
1178 set at top of the function */
1179 if ((i
== 15) && (value
[i
] != 0))
1180 printk(KERN_WARNING
"CIFS: server net"
1181 "biosname longer than 15 truncated.\n");
1183 } else if (strnicmp(data
, "credentials", 4) == 0) {
1185 } else if (strnicmp(data
, "version", 3) == 0) {
1187 } else if (strnicmp(data
, "guest", 5) == 0) {
1189 } else if (strnicmp(data
, "rw", 2) == 0) {
1191 } else if ((strnicmp(data
, "suid", 4) == 0) ||
1192 (strnicmp(data
, "nosuid", 6) == 0) ||
1193 (strnicmp(data
, "exec", 4) == 0) ||
1194 (strnicmp(data
, "noexec", 6) == 0) ||
1195 (strnicmp(data
, "nodev", 5) == 0) ||
1196 (strnicmp(data
, "noauto", 6) == 0) ||
1197 (strnicmp(data
, "dev", 3) == 0)) {
1198 /* The mount tool or mount.cifs helper (if present)
1199 uses these opts to set flags, and the flags are read
1200 by the kernel vfs layer before we get here (ie
1201 before read super) so there is no point trying to
1202 parse these options again and set anything and it
1203 is ok to just ignore them */
1205 } else if (strnicmp(data
, "ro", 2) == 0) {
1207 } else if (strnicmp(data
, "hard", 4) == 0) {
1209 } else if (strnicmp(data
, "soft", 4) == 0) {
1211 } else if (strnicmp(data
, "perm", 4) == 0) {
1213 } else if (strnicmp(data
, "noperm", 6) == 0) {
1215 } else if (strnicmp(data
, "mapchars", 8) == 0) {
1217 } else if (strnicmp(data
, "nomapchars", 10) == 0) {
1219 } else if (strnicmp(data
, "sfu", 3) == 0) {
1221 } else if (strnicmp(data
, "nosfu", 5) == 0) {
1223 } else if (strnicmp(data
, "posixpaths", 10) == 0) {
1224 vol
->posix_paths
= 1;
1225 } else if (strnicmp(data
, "noposixpaths", 12) == 0) {
1226 vol
->posix_paths
= 0;
1227 } else if (strnicmp(data
, "nounix", 6) == 0) {
1228 vol
->no_linux_ext
= 1;
1229 } else if (strnicmp(data
, "nolinux", 7) == 0) {
1230 vol
->no_linux_ext
= 1;
1231 } else if ((strnicmp(data
, "nocase", 6) == 0) ||
1232 (strnicmp(data
, "ignorecase", 10) == 0)) {
1234 } else if (strnicmp(data
, "brl", 3) == 0) {
1236 } else if ((strnicmp(data
, "nobrl", 5) == 0) ||
1237 (strnicmp(data
, "nolock", 6) == 0)) {
1239 /* turn off mandatory locking in mode
1240 if remote locking is turned off since the
1241 local vfs will do advisory */
1242 if (vol
->file_mode
==
1243 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1244 vol
->file_mode
= S_IALLUGO
;
1245 } else if (strnicmp(data
, "setuids", 7) == 0) {
1247 } else if (strnicmp(data
, "nosetuids", 9) == 0) {
1249 } else if (strnicmp(data
, "nohard", 6) == 0) {
1251 } else if (strnicmp(data
, "nosoft", 6) == 0) {
1253 } else if (strnicmp(data
, "nointr", 6) == 0) {
1255 } else if (strnicmp(data
, "intr", 4) == 0) {
1257 } else if (strnicmp(data
, "serverino", 7) == 0) {
1258 vol
->server_ino
= 1;
1259 } else if (strnicmp(data
, "noserverino", 9) == 0) {
1260 vol
->server_ino
= 0;
1261 } else if (strnicmp(data
, "cifsacl", 7) == 0) {
1263 } else if (strnicmp(data
, "nocifsacl", 9) == 0) {
1265 } else if (strnicmp(data
, "acl", 3) == 0) {
1266 vol
->no_psx_acl
= 0;
1267 } else if (strnicmp(data
, "noacl", 5) == 0) {
1268 vol
->no_psx_acl
= 1;
1269 } else if (strnicmp(data
, "sign", 4) == 0) {
1270 vol
->secFlg
|= CIFSSEC_MUST_SIGN
;
1271 /* } else if (strnicmp(data, "seal",4) == 0) {
1272 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1273 } else if (strnicmp(data
, "direct", 6) == 0) {
1275 } else if (strnicmp(data
, "forcedirectio", 13) == 0) {
1277 } else if (strnicmp(data
, "in6_addr", 8) == 0) {
1278 if (!value
|| !*value
) {
1279 vol
->in6_addr
= NULL
;
1280 } else if (strnlen(value
, 49) == 48) {
1281 vol
->in6_addr
= value
;
1283 printk(KERN_WARNING
"CIFS: ip v6 address not "
1284 "48 characters long\n");
1287 } else if (strnicmp(data
, "noac", 4) == 0) {
1288 printk(KERN_WARNING
"CIFS: Mount option noac not "
1289 "supported. Instead set "
1290 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1292 printk(KERN_WARNING
"CIFS: Unknown mount option %s\n",
1295 if (vol
->UNC
== NULL
) {
1296 if (devname
== NULL
) {
1297 printk(KERN_WARNING
"CIFS: Missing UNC name for mount "
1301 if ((temp_len
= strnlen(devname
, 300)) < 300) {
1302 vol
->UNC
= kmalloc(temp_len
+1, GFP_KERNEL
);
1303 if (vol
->UNC
== NULL
)
1305 strcpy(vol
->UNC
, devname
);
1306 if (strncmp(vol
->UNC
, "//", 2) == 0) {
1309 } else if (strncmp(vol
->UNC
, "\\\\", 2) != 0) {
1310 printk(KERN_WARNING
"CIFS: UNC Path does not "
1311 "begin with // or \\\\ \n");
1314 value
= strpbrk(vol
->UNC
+2, "/\\");
1318 printk(KERN_WARNING
"CIFS: UNC name too long\n");
1322 if (vol
->UNCip
== NULL
)
1323 vol
->UNCip
= &vol
->UNC
[2];
1328 static struct cifsSesInfo
*
1329 cifs_find_tcp_session(struct in_addr
*target_ip_addr
,
1330 struct in6_addr
*target_ip6_addr
,
1331 char *userName
, struct TCP_Server_Info
**psrvTcp
)
1333 struct list_head
*tmp
;
1334 struct cifsSesInfo
*ses
;
1338 read_lock(&GlobalSMBSeslock
);
1339 list_for_each(tmp
, &GlobalSMBSessionList
) {
1340 ses
= list_entry(tmp
, struct cifsSesInfo
, cifsSessionList
);
1344 if (target_ip_addr
&&
1345 ses
->server
->addr
.sockAddr
.sin_addr
.s_addr
!= target_ip_addr
->s_addr
)
1347 else if (target_ip6_addr
&&
1348 memcmp(&ses
->server
->addr
.sockAddr6
.sin6_addr
,
1349 target_ip6_addr
, sizeof(*target_ip6_addr
)))
1351 /* BB lock server and tcp session; increment use count here?? */
1353 /* found a match on the TCP session */
1354 *psrvTcp
= ses
->server
;
1356 /* BB check if reconnection needed */
1357 if (strncmp(ses
->userName
, userName
, MAX_USERNAME_SIZE
) == 0) {
1358 read_unlock(&GlobalSMBSeslock
);
1359 /* Found exact match on both TCP and
1363 /* else tcp and smb sessions need reconnection */
1365 read_unlock(&GlobalSMBSeslock
);
1370 static struct cifsTconInfo
*
1371 find_unc(__be32 new_target_ip_addr
, char *uncName
, char *userName
)
1373 struct list_head
*tmp
;
1374 struct cifsTconInfo
*tcon
;
1377 read_lock(&GlobalSMBSeslock
);
1379 list_for_each(tmp
, &GlobalTreeConnectionList
) {
1380 cFYI(1, ("Next tcon"));
1381 tcon
= list_entry(tmp
, struct cifsTconInfo
, cifsConnectionList
);
1382 if (!tcon
->ses
|| !tcon
->ses
->server
)
1385 old_ip
= tcon
->ses
->server
->addr
.sockAddr
.sin_addr
.s_addr
;
1386 cFYI(1, ("old ip addr: %x == new ip %x ?",
1387 old_ip
, new_target_ip_addr
));
1389 if (old_ip
!= new_target_ip_addr
)
1392 /* BB lock tcon, server, tcp session and increment use count? */
1393 /* found a match on the TCP session */
1394 /* BB check if reconnection needed */
1395 cFYI(1, ("IP match, old UNC: %s new: %s",
1396 tcon
->treeName
, uncName
));
1398 if (strncmp(tcon
->treeName
, uncName
, MAX_TREE_SIZE
))
1401 cFYI(1, ("and old usr: %s new: %s",
1402 tcon
->treeName
, uncName
));
1404 if (strncmp(tcon
->ses
->userName
, userName
, MAX_USERNAME_SIZE
))
1407 /* matched smb session (user name) */
1408 read_unlock(&GlobalSMBSeslock
);
1412 read_unlock(&GlobalSMBSeslock
);
1417 connect_to_dfs_path(int xid
, struct cifsSesInfo
*pSesInfo
,
1418 const char *old_path
, const struct nls_table
*nls_codepage
,
1421 struct dfs_info3_param
*referrals
= NULL
;
1422 unsigned int num_referrals
;
1425 rc
= get_dfs_path(xid
, pSesInfo
, old_path
, nls_codepage
,
1426 &num_referrals
, &referrals
, remap
);
1428 /* BB Add in code to: if valid refrl, if not ip address contact
1429 the helper that resolves tcp names, mount to it, try to
1430 tcon to it unmount it if fail */
1438 get_dfs_path(int xid
, struct cifsSesInfo
*pSesInfo
, const char *old_path
,
1439 const struct nls_table
*nls_codepage
, unsigned int *pnum_referrals
,
1440 struct dfs_info3_param
**preferrals
, int remap
)
1444 unsigned char *targetUNCs
;
1446 *pnum_referrals
= 0;
1449 if (pSesInfo
->ipc_tid
== 0) {
1450 temp_unc
= kmalloc(2 /* for slashes */ +
1451 strnlen(pSesInfo
->serverName
,
1452 SERVER_NAME_LEN_WITH_NULL
* 2)
1453 + 1 + 4 /* slash IPC$ */ + 2,
1455 if (temp_unc
== NULL
)
1459 strcpy(temp_unc
+ 2, pSesInfo
->serverName
);
1460 strcpy(temp_unc
+ 2 + strlen(pSesInfo
->serverName
), "\\IPC$");
1461 rc
= CIFSTCon(xid
, pSesInfo
, temp_unc
, NULL
, nls_codepage
);
1463 ("CIFS Tcon rc = %d ipc_tid = %d", rc
, pSesInfo
->ipc_tid
));
1467 rc
= CIFSGetDFSRefer(xid
, pSesInfo
, old_path
, &targetUNCs
,
1468 pnum_referrals
, nls_codepage
, remap
);
1469 /* BB map targetUNCs to dfs_info3 structures, here or
1470 in CIFSGetDFSRefer BB */
1475 /* See RFC1001 section 14 on representation of Netbios names */
1476 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
1480 for (i
= 0, j
= 0; i
< (length
); i
++) {
1481 /* mask a nibble at a time and encode */
1482 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
1483 target
[j
+1] = 'A' + (0x0F & source
[i
]);
1491 ipv4_connect(struct sockaddr_in
*psin_server
, struct socket
**csocket
,
1492 char *netbios_name
, char *target_name
)
1496 __be16 orig_port
= 0;
1498 if (*csocket
== NULL
) {
1499 rc
= sock_create_kern(PF_INET
, SOCK_STREAM
,
1500 IPPROTO_TCP
, csocket
);
1502 cERROR(1, ("Error %d creating socket", rc
));
1506 /* BB other socket options to set KEEPALIVE, NODELAY? */
1507 cFYI(1, ("Socket created"));
1508 (*csocket
)->sk
->sk_allocation
= GFP_NOFS
;
1512 psin_server
->sin_family
= AF_INET
;
1513 if (psin_server
->sin_port
) { /* user overrode default port */
1514 rc
= (*csocket
)->ops
->connect(*csocket
,
1515 (struct sockaddr
*) psin_server
,
1516 sizeof(struct sockaddr_in
), 0);
1522 /* save original port so we can retry user specified port
1523 later if fall back ports fail this time */
1524 orig_port
= psin_server
->sin_port
;
1526 /* do not retry on the same port we just failed on */
1527 if (psin_server
->sin_port
!= htons(CIFS_PORT
)) {
1528 psin_server
->sin_port
= htons(CIFS_PORT
);
1530 rc
= (*csocket
)->ops
->connect(*csocket
,
1531 (struct sockaddr
*) psin_server
,
1532 sizeof(struct sockaddr_in
), 0);
1538 psin_server
->sin_port
= htons(RFC1001_PORT
);
1539 rc
= (*csocket
)->ops
->connect(*csocket
, (struct sockaddr
*)
1541 sizeof(struct sockaddr_in
), 0);
1546 /* give up here - unless we want to retry on different
1547 protocol families some day */
1550 psin_server
->sin_port
= orig_port
;
1551 cFYI(1, ("Error %d connecting to server via ipv4", rc
));
1552 sock_release(*csocket
);
1556 /* Eventually check for other socket options to change from
1557 the default. sock_setsockopt not used because it expects
1558 user space buffer */
1559 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1560 (*csocket
)->sk
->sk_sndbuf
,
1561 (*csocket
)->sk
->sk_rcvbuf
, (*csocket
)->sk
->sk_rcvtimeo
));
1562 (*csocket
)->sk
->sk_rcvtimeo
= 7 * HZ
;
1563 /* make the bufsizes depend on wsize/rsize and max requests */
1564 if ((*csocket
)->sk
->sk_sndbuf
< (200 * 1024))
1565 (*csocket
)->sk
->sk_sndbuf
= 200 * 1024;
1566 if ((*csocket
)->sk
->sk_rcvbuf
< (140 * 1024))
1567 (*csocket
)->sk
->sk_rcvbuf
= 140 * 1024;
1569 /* send RFC1001 sessinit */
1570 if (psin_server
->sin_port
== htons(RFC1001_PORT
)) {
1571 /* some servers require RFC1001 sessinit before sending
1572 negprot - BB check reconnection in case where second
1573 sessinit is sent but no second negprot */
1574 struct rfc1002_session_packet
*ses_init_buf
;
1575 struct smb_hdr
*smb_buf
;
1576 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
1579 ses_init_buf
->trailer
.session_req
.called_len
= 32;
1580 if (target_name
&& (target_name
[0] != 0)) {
1581 rfc1002mangle(ses_init_buf
->trailer
.session_req
.called_name
,
1584 rfc1002mangle(ses_init_buf
->trailer
.session_req
.called_name
,
1585 DEFAULT_CIFS_CALLED_NAME
, 16);
1588 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
1589 /* calling name ends in null (byte 16) from old smb
1591 if (netbios_name
&& (netbios_name
[0] != 0)) {
1592 rfc1002mangle(ses_init_buf
->trailer
.session_req
.calling_name
,
1595 rfc1002mangle(ses_init_buf
->trailer
.session_req
.calling_name
,
1596 "LINUX_CIFS_CLNT", 16);
1598 ses_init_buf
->trailer
.session_req
.scope1
= 0;
1599 ses_init_buf
->trailer
.session_req
.scope2
= 0;
1600 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
1601 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1602 smb_buf
->smb_buf_length
= 0x81000044;
1603 rc
= smb_send(*csocket
, smb_buf
, 0x44,
1604 (struct sockaddr
*)psin_server
);
1605 kfree(ses_init_buf
);
1606 msleep(1); /* RFC1001 layer in at least one server
1607 requires very short break before negprot
1608 presumably because not expecting negprot
1609 to follow so fast. This is a simple
1610 solution that works without
1611 complicating the code and causes no
1612 significant slowing down on mount
1613 for everyone else */
1615 /* else the negprot may still work without this
1616 even though malloc failed */
1624 ipv6_connect(struct sockaddr_in6
*psin_server
, struct socket
**csocket
)
1628 __be16 orig_port
= 0;
1630 if (*csocket
== NULL
) {
1631 rc
= sock_create_kern(PF_INET6
, SOCK_STREAM
,
1632 IPPROTO_TCP
, csocket
);
1634 cERROR(1, ("Error %d creating ipv6 socket", rc
));
1638 /* BB other socket options to set KEEPALIVE, NODELAY? */
1639 cFYI(1, ("ipv6 Socket created"));
1640 (*csocket
)->sk
->sk_allocation
= GFP_NOFS
;
1644 psin_server
->sin6_family
= AF_INET6
;
1646 if (psin_server
->sin6_port
) { /* user overrode default port */
1647 rc
= (*csocket
)->ops
->connect(*csocket
,
1648 (struct sockaddr
*) psin_server
,
1649 sizeof(struct sockaddr_in6
), 0);
1655 /* save original port so we can retry user specified port
1656 later if fall back ports fail this time */
1658 orig_port
= psin_server
->sin6_port
;
1659 /* do not retry on the same port we just failed on */
1660 if (psin_server
->sin6_port
!= htons(CIFS_PORT
)) {
1661 psin_server
->sin6_port
= htons(CIFS_PORT
);
1663 rc
= (*csocket
)->ops
->connect(*csocket
,
1664 (struct sockaddr
*) psin_server
,
1665 sizeof(struct sockaddr_in6
), 0);
1671 psin_server
->sin6_port
= htons(RFC1001_PORT
);
1672 rc
= (*csocket
)->ops
->connect(*csocket
, (struct sockaddr
*)
1673 psin_server
, sizeof(struct sockaddr_in6
), 0);
1678 /* give up here - unless we want to retry on different
1679 protocol families some day */
1682 psin_server
->sin6_port
= orig_port
;
1683 cFYI(1, ("Error %d connecting to server via ipv6", rc
));
1684 sock_release(*csocket
);
1688 /* Eventually check for other socket options to change from
1689 the default. sock_setsockopt not used because it expects
1690 user space buffer */
1691 (*csocket
)->sk
->sk_rcvtimeo
= 7 * HZ
;
1696 void reset_cifs_unix_caps(int xid
, struct cifsTconInfo
*tcon
,
1697 struct super_block
*sb
, struct smb_vol
*vol_info
)
1699 /* if we are reconnecting then should we check to see if
1700 * any requested capabilities changed locally e.g. via
1701 * remount but we can not do much about it here
1702 * if they have (even if we could detect it by the following)
1703 * Perhaps we could add a backpointer to array of sb from tcon
1704 * or if we change to make all sb to same share the same
1705 * sb as NFS - then we only have one backpointer to sb.
1706 * What if we wanted to mount the server share twice once with
1707 * and once without posixacls or posix paths? */
1708 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
1710 if (vol_info
&& vol_info
->no_linux_ext
) {
1711 tcon
->fsUnixInfo
.Capability
= 0;
1712 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
1713 cFYI(1, ("Linux protocol extensions disabled"));
1715 } else if (vol_info
)
1716 tcon
->unix_ext
= 1; /* Unix Extensions supported */
1718 if (tcon
->unix_ext
== 0) {
1719 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1723 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
1724 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
1726 /* check for reconnect case in which we do not
1727 want to change the mount behavior if we can avoid it */
1728 if (vol_info
== NULL
) {
1729 /* turn off POSIX ACL and PATHNAMES if not set
1730 originally at mount time */
1731 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
1732 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
1733 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
1734 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
1735 cERROR(1, ("POSIXPATH support change"));
1736 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
1737 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
1738 cERROR(1, ("possible reconnect error"));
1740 ("server disabled POSIX path support"));
1744 cap
&= CIFS_UNIX_CAP_MASK
;
1745 if (vol_info
&& vol_info
->no_psx_acl
)
1746 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
1747 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
1748 cFYI(1, ("negotiated posix acl support"));
1750 sb
->s_flags
|= MS_POSIXACL
;
1753 if (vol_info
&& vol_info
->posix_paths
== 0)
1754 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
1755 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
1756 cFYI(1, ("negotiate posix pathnames"));
1758 CIFS_SB(sb
)->mnt_cifs_flags
|=
1759 CIFS_MOUNT_POSIX_PATHS
;
1762 /* We might be setting the path sep back to a different
1763 form if we are reconnecting and the server switched its
1764 posix path capability for this share */
1765 if (sb
&& (CIFS_SB(sb
)->prepathlen
> 0))
1766 CIFS_SB(sb
)->prepath
[0] = CIFS_DIR_SEP(CIFS_SB(sb
));
1768 if (sb
&& (CIFS_SB(sb
)->rsize
> 127 * 1024)) {
1769 if ((cap
& CIFS_UNIX_LARGE_READ_CAP
) == 0) {
1770 CIFS_SB(sb
)->rsize
= 127 * 1024;
1772 ("larger reads not supported by srv"));
1777 cFYI(1, ("Negotiate caps 0x%x", (int)cap
));
1778 #ifdef CONFIG_CIFS_DEBUG2
1779 if (cap
& CIFS_UNIX_FCNTL_CAP
)
1780 cFYI(1, ("FCNTL cap"));
1781 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
1782 cFYI(1, ("EXTATTR cap"));
1783 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
1784 cFYI(1, ("POSIX path cap"));
1785 if (cap
& CIFS_UNIX_XATTR_CAP
)
1786 cFYI(1, ("XATTR cap"));
1787 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
1788 cFYI(1, ("POSIX ACL cap"));
1789 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
1790 cFYI(1, ("very large read cap"));
1791 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
1792 cFYI(1, ("very large write cap"));
1793 #endif /* CIFS_DEBUG2 */
1794 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
1795 if (vol_info
== NULL
) {
1796 cFYI(1, ("resetting capabilities failed"));
1798 cERROR(1, ("Negotiating Unix capabilities "
1799 "with the server failed. Consider "
1800 "mounting with the Unix Extensions\n"
1801 "disabled, if problems are found, "
1802 "by specifying the nounix mount "
1810 convert_delimiter(char *path
, char delim
)
1823 for (i
= 0; path
[i
] != '\0'; i
++) {
1824 if (path
[i
] == old_delim
)
1830 cifs_mount(struct super_block
*sb
, struct cifs_sb_info
*cifs_sb
,
1831 char *mount_data
, const char *devname
)
1835 int address_type
= AF_INET
;
1836 struct socket
*csocket
= NULL
;
1837 struct sockaddr_in sin_server
;
1838 struct sockaddr_in6 sin_server6
;
1839 struct smb_vol volume_info
;
1840 struct cifsSesInfo
*pSesInfo
= NULL
;
1841 struct cifsSesInfo
*existingCifsSes
= NULL
;
1842 struct cifsTconInfo
*tcon
= NULL
;
1843 struct TCP_Server_Info
*srvTcp
= NULL
;
1847 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1849 memset(&volume_info
, 0, sizeof(struct smb_vol
));
1850 if (cifs_parse_mount_options(mount_data
, devname
, &volume_info
)) {
1855 if (volume_info
.nullauth
) {
1856 cFYI(1, ("null user"));
1857 volume_info
.username
= "";
1858 } else if (volume_info
.username
) {
1859 /* BB fixme parse for domain name here */
1860 cFYI(1, ("Username: %s", volume_info
.username
));
1862 cifserror("No username specified");
1863 /* In userspace mount helper we can get user name from alternate
1864 locations such as env variables and files on disk */
1869 if (volume_info
.UNCip
&& volume_info
.UNC
) {
1870 rc
= cifs_inet_pton(AF_INET
, volume_info
.UNCip
,
1871 &sin_server
.sin_addr
.s_addr
);
1874 /* not ipv4 address, try ipv6 */
1875 rc
= cifs_inet_pton(AF_INET6
, volume_info
.UNCip
,
1876 &sin_server6
.sin6_addr
.in6_u
);
1878 address_type
= AF_INET6
;
1880 address_type
= AF_INET
;
1884 /* we failed translating address */
1889 cFYI(1, ("UNC: %s ip: %s", volume_info
.UNC
, volume_info
.UNCip
));
1892 } else if (volume_info
.UNCip
) {
1893 /* BB using ip addr as server name to connect to the
1895 cERROR(1, ("Connecting to DFS root not implemented yet"));
1898 } else /* which servers DFS root would we conect to */ {
1900 ("CIFS mount error: No UNC path (e.g. -o "
1901 "unc=//192.168.1.100/public) specified"));
1906 /* this is needed for ASCII cp to Unicode converts */
1907 if (volume_info
.iocharset
== NULL
) {
1908 cifs_sb
->local_nls
= load_nls_default();
1909 /* load_nls_default can not return null */
1911 cifs_sb
->local_nls
= load_nls(volume_info
.iocharset
);
1912 if (cifs_sb
->local_nls
== NULL
) {
1913 cERROR(1, ("CIFS mount error: iocharset %s not found",
1914 volume_info
.iocharset
));
1920 if (address_type
== AF_INET
)
1921 existingCifsSes
= cifs_find_tcp_session(&sin_server
.sin_addr
,
1922 NULL
/* no ipv6 addr */,
1923 volume_info
.username
, &srvTcp
);
1924 else if (address_type
== AF_INET6
) {
1925 cFYI(1, ("looking for ipv6 address"));
1926 existingCifsSes
= cifs_find_tcp_session(NULL
/* no ipv4 addr */,
1927 &sin_server6
.sin6_addr
,
1928 volume_info
.username
, &srvTcp
);
1935 cFYI(1, ("Existing tcp session with server found"));
1936 } else { /* create socket */
1937 if (volume_info
.port
)
1938 sin_server
.sin_port
= htons(volume_info
.port
);
1940 sin_server
.sin_port
= 0;
1941 if (address_type
== AF_INET6
) {
1942 cFYI(1, ("attempting ipv6 connect"));
1943 /* BB should we allow ipv6 on port 139? */
1944 /* other OS never observed in Wild doing 139 with v6 */
1945 rc
= ipv6_connect(&sin_server6
, &csocket
);
1947 rc
= ipv4_connect(&sin_server
, &csocket
,
1948 volume_info
.source_rfc1001_name
,
1949 volume_info
.target_rfc1001_name
);
1951 cERROR(1, ("Error connecting to IPv4 socket. "
1952 "Aborting operation"));
1953 if (csocket
!= NULL
)
1954 sock_release(csocket
);
1958 srvTcp
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
1961 sock_release(csocket
);
1964 memcpy(&srvTcp
->addr
.sockAddr
, &sin_server
,
1965 sizeof(struct sockaddr_in
));
1966 atomic_set(&srvTcp
->inFlight
, 0);
1967 /* BB Add code for ipv6 case too */
1968 srvTcp
->ssocket
= csocket
;
1969 srvTcp
->protocolType
= IPV4
;
1970 srvTcp
->hostname
= extract_hostname(volume_info
.UNC
);
1971 if (IS_ERR(srvTcp
->hostname
)) {
1972 rc
= PTR_ERR(srvTcp
->hostname
);
1973 sock_release(csocket
);
1976 init_waitqueue_head(&srvTcp
->response_q
);
1977 init_waitqueue_head(&srvTcp
->request_q
);
1978 INIT_LIST_HEAD(&srvTcp
->pending_mid_q
);
1979 /* at this point we are the only ones with the pointer
1980 to the struct since the kernel thread not created yet
1981 so no need to spinlock this init of tcpStatus */
1982 srvTcp
->tcpStatus
= CifsNew
;
1983 init_MUTEX(&srvTcp
->tcpSem
);
1984 srvTcp
->tsk
= kthread_run((void *)(void *)cifs_demultiplex_thread
, srvTcp
, "cifsd");
1985 if (IS_ERR(srvTcp
->tsk
)) {
1986 rc
= PTR_ERR(srvTcp
->tsk
);
1987 cERROR(1, ("error %d create cifsd thread", rc
));
1989 sock_release(csocket
);
1990 kfree(srvTcp
->hostname
);
1994 memcpy(srvTcp
->workstation_RFC1001_name
,
1995 volume_info
.source_rfc1001_name
, 16);
1996 memcpy(srvTcp
->server_RFC1001_name
,
1997 volume_info
.target_rfc1001_name
, 16);
1998 srvTcp
->sequence_number
= 0;
2002 if (existingCifsSes
) {
2003 pSesInfo
= existingCifsSes
;
2004 cFYI(1, ("Existing smb sess found (status=%d)",
2006 down(&pSesInfo
->sesSem
);
2007 if (pSesInfo
->status
== CifsNeedReconnect
) {
2008 cFYI(1, ("Session needs reconnect"));
2009 rc
= cifs_setup_session(xid
, pSesInfo
,
2010 cifs_sb
->local_nls
);
2012 up(&pSesInfo
->sesSem
);
2014 cFYI(1, ("Existing smb sess not found"));
2015 pSesInfo
= sesInfoAlloc();
2016 if (pSesInfo
== NULL
)
2019 pSesInfo
->server
= srvTcp
;
2020 sprintf(pSesInfo
->serverName
, "%u.%u.%u.%u",
2021 NIPQUAD(sin_server
.sin_addr
.s_addr
));
2025 /* volume_info.password freed at unmount */
2026 if (volume_info
.password
) {
2027 pSesInfo
->password
= volume_info
.password
;
2028 /* set to NULL to prevent freeing on exit */
2029 volume_info
.password
= NULL
;
2031 if (volume_info
.username
)
2032 strncpy(pSesInfo
->userName
,
2033 volume_info
.username
,
2035 if (volume_info
.domainname
) {
2036 int len
= strlen(volume_info
.domainname
);
2037 pSesInfo
->domainName
=
2038 kmalloc(len
+ 1, GFP_KERNEL
);
2039 if (pSesInfo
->domainName
)
2040 strcpy(pSesInfo
->domainName
,
2041 volume_info
.domainname
);
2043 pSesInfo
->linux_uid
= volume_info
.linux_uid
;
2044 pSesInfo
->overrideSecFlg
= volume_info
.secFlg
;
2045 down(&pSesInfo
->sesSem
);
2046 /* BB FIXME need to pass vol->secFlgs BB */
2047 rc
= cifs_setup_session(xid
, pSesInfo
,
2048 cifs_sb
->local_nls
);
2049 up(&pSesInfo
->sesSem
);
2051 atomic_inc(&srvTcp
->socketUseCount
);
2055 /* search for existing tcon to this server share */
2057 if (volume_info
.rsize
> CIFSMaxBufSize
) {
2058 cERROR(1, ("rsize %d too large, using MaxBufSize",
2059 volume_info
.rsize
));
2060 cifs_sb
->rsize
= CIFSMaxBufSize
;
2061 } else if ((volume_info
.rsize
) &&
2062 (volume_info
.rsize
<= CIFSMaxBufSize
))
2063 cifs_sb
->rsize
= volume_info
.rsize
;
2065 cifs_sb
->rsize
= CIFSMaxBufSize
;
2067 if (volume_info
.wsize
> PAGEVEC_SIZE
* PAGE_CACHE_SIZE
) {
2068 cERROR(1, ("wsize %d too large, using 4096 instead",
2069 volume_info
.wsize
));
2070 cifs_sb
->wsize
= 4096;
2071 } else if (volume_info
.wsize
)
2072 cifs_sb
->wsize
= volume_info
.wsize
;
2075 min_t(const int, PAGEVEC_SIZE
* PAGE_CACHE_SIZE
,
2077 /* old default of CIFSMaxBufSize was too small now
2078 that SMB Write2 can send multiple pages in kvec.
2079 RFC1001 does not describe what happens when frame
2080 bigger than 128K is sent so use that as max in
2081 conjunction with 52K kvec constraint on arch with 4K
2084 if (cifs_sb
->rsize
< 2048) {
2085 cifs_sb
->rsize
= 2048;
2086 /* Windows ME may prefer this */
2087 cFYI(1, ("readsize set to minimum: 2048"));
2089 /* calculate prepath */
2090 cifs_sb
->prepath
= volume_info
.prepath
;
2091 if (cifs_sb
->prepath
) {
2092 cifs_sb
->prepathlen
= strlen(cifs_sb
->prepath
);
2093 /* we can not convert the / to \ in the path
2094 separators in the prefixpath yet because we do not
2095 know (until reset_cifs_unix_caps is called later)
2096 whether POSIX PATH CAP is available. We normalize
2097 the / to \ after reset_cifs_unix_caps is called */
2098 volume_info
.prepath
= NULL
;
2100 cifs_sb
->prepathlen
= 0;
2101 cifs_sb
->mnt_uid
= volume_info
.linux_uid
;
2102 cifs_sb
->mnt_gid
= volume_info
.linux_gid
;
2103 cifs_sb
->mnt_file_mode
= volume_info
.file_mode
;
2104 cifs_sb
->mnt_dir_mode
= volume_info
.dir_mode
;
2105 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2106 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
));
2108 if (volume_info
.noperm
)
2109 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
2110 if (volume_info
.setuids
)
2111 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
2112 if (volume_info
.server_ino
)
2113 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
2114 if (volume_info
.remap
)
2115 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
2116 if (volume_info
.no_xattr
)
2117 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
2118 if (volume_info
.sfu_emul
)
2119 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
2120 if (volume_info
.nobrl
)
2121 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
2122 if (volume_info
.cifs_acl
)
2123 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
2124 if (volume_info
.override_uid
)
2125 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
2126 if (volume_info
.override_gid
)
2127 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
2128 if (volume_info
.direct_io
) {
2129 cFYI(1, ("mounting share using direct i/o"));
2130 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
2134 find_unc(sin_server
.sin_addr
.s_addr
, volume_info
.UNC
,
2135 volume_info
.username
);
2137 cFYI(1, ("Found match on UNC path"));
2138 /* we can have only one retry value for a connection
2139 to a share so for resources mounted more than once
2140 to the same server share the last value passed in
2141 for the retry flag is used */
2142 tcon
->retry
= volume_info
.retry
;
2143 tcon
->nocase
= volume_info
.nocase
;
2145 tcon
= tconInfoAlloc();
2149 /* check for null share name ie connecting to
2152 /* BB check if this works for exactly length
2154 if ((strchr(volume_info
.UNC
+ 3, '\\') == NULL
)
2155 && (strchr(volume_info
.UNC
+ 3, '/') ==
2157 rc
= connect_to_dfs_path(xid
, pSesInfo
,
2158 "", cifs_sb
->local_nls
,
2159 cifs_sb
->mnt_cifs_flags
&
2160 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2164 /* BB Do we need to wrap sesSem around
2165 * this TCon call and Unix SetFS as
2166 * we do on SessSetup and reconnect? */
2167 rc
= CIFSTCon(xid
, pSesInfo
,
2169 tcon
, cifs_sb
->local_nls
);
2170 cFYI(1, ("CIFS Tcon rc = %d", rc
));
2173 atomic_inc(&pSesInfo
->inUse
);
2174 tcon
->retry
= volume_info
.retry
;
2175 tcon
->nocase
= volume_info
.nocase
;
2181 if (pSesInfo
->capabilities
& CAP_LARGE_FILES
) {
2182 sb
->s_maxbytes
= (u64
) 1 << 63;
2184 sb
->s_maxbytes
= (u64
) 1 << 31; /* 2 GB */
2187 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2188 sb
->s_time_gran
= 100;
2190 /* on error free sesinfo and tcon struct if needed */
2192 /* if session setup failed, use count is zero but
2193 we still need to free cifsd thread */
2194 if (atomic_read(&srvTcp
->socketUseCount
) == 0) {
2195 spin_lock(&GlobalMid_Lock
);
2196 srvTcp
->tcpStatus
= CifsExiting
;
2197 spin_unlock(&GlobalMid_Lock
);
2199 /* If we could verify that kthread_stop would
2200 always wake up processes blocked in
2201 tcp in recv_mesg then we could remove the
2203 force_sig(SIGKILL
, srvTcp
->tsk
);
2204 kthread_stop(srvTcp
->tsk
);
2207 /* If find_unc succeeded then rc == 0 so we can not end */
2208 if (tcon
) /* up accidently freeing someone elses tcon struct */
2210 if (existingCifsSes
== NULL
) {
2212 if ((pSesInfo
->server
) &&
2213 (pSesInfo
->status
== CifsGood
)) {
2215 temp_rc
= CIFSSMBLogoff(xid
, pSesInfo
);
2216 /* if the socketUseCount is now zero */
2217 if ((temp_rc
== -ESHUTDOWN
) &&
2218 (pSesInfo
->server
) &&
2219 (pSesInfo
->server
->tsk
)) {
2221 pSesInfo
->server
->tsk
);
2222 kthread_stop(pSesInfo
->server
->tsk
);
2225 cFYI(1, ("No session or bad tcon"));
2226 if ((pSesInfo
->server
) &&
2227 (pSesInfo
->server
->tsk
)) {
2229 pSesInfo
->server
->tsk
);
2230 kthread_stop(pSesInfo
->server
->tsk
);
2233 sesInfoFree(pSesInfo
);
2234 /* pSesInfo = NULL; */
2238 atomic_inc(&tcon
->useCount
);
2239 cifs_sb
->tcon
= tcon
;
2240 tcon
->ses
= pSesInfo
;
2242 /* do not care if following two calls succeed - informational */
2244 CIFSSMBQFSDeviceInfo(xid
, tcon
);
2245 CIFSSMBQFSAttributeInfo(xid
, tcon
);
2248 /* tell server which Unix caps we support */
2249 if (tcon
->ses
->capabilities
& CAP_UNIX
)
2250 /* reset of caps checks mount to see if unix extensions
2251 disabled for just this mount */
2252 reset_cifs_unix_caps(xid
, tcon
, sb
, &volume_info
);
2254 tcon
->unix_ext
= 0; /* server does not support them */
2256 /* convert forward to back slashes in prepath here if needed */
2257 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) == 0)
2258 convert_delimiter(cifs_sb
->prepath
,
2259 CIFS_DIR_SEP(cifs_sb
));
2261 if ((tcon
->unix_ext
== 0) && (cifs_sb
->rsize
> (1024 * 127))) {
2262 cifs_sb
->rsize
= 1024 * 127;
2264 ("no very large read support, rsize now 127K"));
2266 if (!(tcon
->ses
->capabilities
& CAP_LARGE_WRITE_X
))
2267 cifs_sb
->wsize
= min(cifs_sb
->wsize
,
2268 (tcon
->ses
->server
->maxBuf
-
2269 MAX_CIFS_HDR_SIZE
));
2270 if (!(tcon
->ses
->capabilities
& CAP_LARGE_READ_X
))
2271 cifs_sb
->rsize
= min(cifs_sb
->rsize
,
2272 (tcon
->ses
->server
->maxBuf
-
2273 MAX_CIFS_HDR_SIZE
));
2276 /* volume_info.password is freed above when existing session found
2277 (in which case it is not needed anymore) but when new sesion is created
2278 the password ptr is put in the new session structure (in which case the
2279 password will be freed at unmount time) */
2281 /* zero out password before freeing */
2282 if (volume_info
.password
!= NULL
) {
2283 memset(volume_info
.password
, 0, strlen(volume_info
.password
));
2284 kfree(volume_info
.password
);
2286 kfree(volume_info
.UNC
);
2287 kfree(volume_info
.prepath
);
2293 CIFSSessSetup(unsigned int xid
, struct cifsSesInfo
*ses
,
2294 char session_key
[CIFS_SESS_KEY_SIZE
],
2295 const struct nls_table
*nls_codepage
)
2297 struct smb_hdr
*smb_buffer
;
2298 struct smb_hdr
*smb_buffer_response
;
2299 SESSION_SETUP_ANDX
*pSMB
;
2300 SESSION_SETUP_ANDX
*pSMBr
;
2305 int remaining_words
= 0;
2306 int bytes_returned
= 0;
2311 cFYI(1, ("In sesssetup"));
2314 user
= ses
->userName
;
2315 domain
= ses
->domainName
;
2316 smb_buffer
= cifs_buf_get();
2317 if (smb_buffer
== NULL
) {
2320 smb_buffer_response
= smb_buffer
;
2321 pSMBr
= pSMB
= (SESSION_SETUP_ANDX
*) smb_buffer
;
2323 /* send SMBsessionSetup here */
2324 header_assemble(smb_buffer
, SMB_COM_SESSION_SETUP_ANDX
,
2325 NULL
/* no tCon exists yet */ , 13 /* wct */ );
2327 smb_buffer
->Mid
= GetNextMid(ses
->server
);
2328 pSMB
->req_no_secext
.AndXCommand
= 0xFF;
2329 pSMB
->req_no_secext
.MaxBufferSize
= cpu_to_le16(ses
->server
->maxBuf
);
2330 pSMB
->req_no_secext
.MaxMpxCount
= cpu_to_le16(ses
->server
->maxReq
);
2332 if (ses
->server
->secMode
&
2333 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
2334 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
2336 capabilities
= CAP_LARGE_FILES
| CAP_NT_SMBS
| CAP_LEVEL_II_OPLOCKS
|
2337 CAP_LARGE_WRITE_X
| CAP_LARGE_READ_X
;
2338 if (ses
->capabilities
& CAP_UNICODE
) {
2339 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
2340 capabilities
|= CAP_UNICODE
;
2342 if (ses
->capabilities
& CAP_STATUS32
) {
2343 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
2344 capabilities
|= CAP_STATUS32
;
2346 if (ses
->capabilities
& CAP_DFS
) {
2347 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
2348 capabilities
|= CAP_DFS
;
2350 pSMB
->req_no_secext
.Capabilities
= cpu_to_le32(capabilities
);
2352 pSMB
->req_no_secext
.CaseInsensitivePasswordLength
=
2353 cpu_to_le16(CIFS_SESS_KEY_SIZE
);
2355 pSMB
->req_no_secext
.CaseSensitivePasswordLength
=
2356 cpu_to_le16(CIFS_SESS_KEY_SIZE
);
2357 bcc_ptr
= pByteArea(smb_buffer
);
2358 memcpy(bcc_ptr
, (char *) session_key
, CIFS_SESS_KEY_SIZE
);
2359 bcc_ptr
+= CIFS_SESS_KEY_SIZE
;
2360 memcpy(bcc_ptr
, (char *) session_key
, CIFS_SESS_KEY_SIZE
);
2361 bcc_ptr
+= CIFS_SESS_KEY_SIZE
;
2363 if (ses
->capabilities
& CAP_UNICODE
) {
2364 if ((long) bcc_ptr
% 2) { /* must be word aligned for Unicode */
2369 bytes_returned
= 0; /* skip null user */
2372 cifs_strtoUCS((__le16
*) bcc_ptr
, user
, 100,
2374 /* convert number of 16 bit words to bytes */
2375 bcc_ptr
+= 2 * bytes_returned
;
2376 bcc_ptr
+= 2; /* trailing null */
2379 cifs_strtoUCS((__le16
*) bcc_ptr
,
2380 "CIFS_LINUX_DOM", 32, nls_codepage
);
2383 cifs_strtoUCS((__le16
*) bcc_ptr
, domain
, 64,
2385 bcc_ptr
+= 2 * bytes_returned
;
2388 cifs_strtoUCS((__le16
*) bcc_ptr
, "Linux version ",
2390 bcc_ptr
+= 2 * bytes_returned
;
2392 cifs_strtoUCS((__le16
*) bcc_ptr
, utsname()->release
,
2394 bcc_ptr
+= 2 * bytes_returned
;
2397 cifs_strtoUCS((__le16
*) bcc_ptr
, CIFS_NETWORK_OPSYS
,
2399 bcc_ptr
+= 2 * bytes_returned
;
2403 strncpy(bcc_ptr
, user
, 200);
2404 bcc_ptr
+= strnlen(user
, 200);
2408 if (domain
== NULL
) {
2409 strcpy(bcc_ptr
, "CIFS_LINUX_DOM");
2410 bcc_ptr
+= strlen("CIFS_LINUX_DOM") + 1;
2412 strncpy(bcc_ptr
, domain
, 64);
2413 bcc_ptr
+= strnlen(domain
, 64);
2417 strcpy(bcc_ptr
, "Linux version ");
2418 bcc_ptr
+= strlen("Linux version ");
2419 strcpy(bcc_ptr
, utsname()->release
);
2420 bcc_ptr
+= strlen(utsname()->release
) + 1;
2421 strcpy(bcc_ptr
, CIFS_NETWORK_OPSYS
);
2422 bcc_ptr
+= strlen(CIFS_NETWORK_OPSYS
) + 1;
2424 count
= (long) bcc_ptr
- (long) pByteArea(smb_buffer
);
2425 smb_buffer
->smb_buf_length
+= count
;
2426 pSMB
->req_no_secext
.ByteCount
= cpu_to_le16(count
);
2428 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
,
2429 &bytes_returned
, CIFS_LONG_OP
);
2431 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2432 } else if ((smb_buffer_response
->WordCount
== 3)
2433 || (smb_buffer_response
->WordCount
== 4)) {
2434 __u16 action
= le16_to_cpu(pSMBr
->resp
.Action
);
2435 __u16 blob_len
= le16_to_cpu(pSMBr
->resp
.SecurityBlobLength
);
2436 if (action
& GUEST_LOGIN
)
2437 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2438 ses
->Suid
= smb_buffer_response
->Uid
; /* UID left in wire format
2440 cFYI(1, ("UID = %d ", ses
->Suid
));
2441 /* response can have either 3 or 4 word count - Samba sends 3 */
2442 bcc_ptr
= pByteArea(smb_buffer_response
);
2443 if ((pSMBr
->resp
.hdr
.WordCount
== 3)
2444 || ((pSMBr
->resp
.hdr
.WordCount
== 4)
2445 && (blob_len
< pSMBr
->resp
.ByteCount
))) {
2446 if (pSMBr
->resp
.hdr
.WordCount
== 4)
2447 bcc_ptr
+= blob_len
;
2449 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
) {
2450 if ((long) (bcc_ptr
) % 2) {
2452 (BCC(smb_buffer_response
) - 1) / 2;
2453 /* Unicode strings must be word
2458 BCC(smb_buffer_response
) / 2;
2461 UniStrnlen((wchar_t *) bcc_ptr
,
2462 remaining_words
- 1);
2463 /* We look for obvious messed up bcc or strings in response so we do not go off
2464 the end since (at least) WIN2K and Windows XP have a major bug in not null
2465 terminating last Unicode string in response */
2467 kfree(ses
->serverOS
);
2468 ses
->serverOS
= kzalloc(2 * (len
+ 1),
2470 if (ses
->serverOS
== NULL
)
2471 goto sesssetup_nomem
;
2472 cifs_strfromUCS_le(ses
->serverOS
,
2475 bcc_ptr
+= 2 * (len
+ 1);
2476 remaining_words
-= len
+ 1;
2477 ses
->serverOS
[2 * len
] = 0;
2478 ses
->serverOS
[1 + (2 * len
)] = 0;
2479 if (remaining_words
> 0) {
2480 len
= UniStrnlen((wchar_t *)bcc_ptr
,
2482 kfree(ses
->serverNOS
);
2483 ses
->serverNOS
= kzalloc(2 * (len
+ 1),
2485 if (ses
->serverNOS
== NULL
)
2486 goto sesssetup_nomem
;
2487 cifs_strfromUCS_le(ses
->serverNOS
,
2490 bcc_ptr
+= 2 * (len
+ 1);
2491 ses
->serverNOS
[2 * len
] = 0;
2492 ses
->serverNOS
[1 + (2 * len
)] = 0;
2493 if (strncmp(ses
->serverNOS
,
2494 "NT LAN Manager 4", 16) == 0) {
2495 cFYI(1, ("NT4 server"));
2496 ses
->flags
|= CIFS_SES_NT4
;
2498 remaining_words
-= len
+ 1;
2499 if (remaining_words
> 0) {
2500 len
= UniStrnlen((wchar_t *) bcc_ptr
, remaining_words
);
2501 /* last string is not always null terminated
2502 (for e.g. for Windows XP & 2000) */
2503 if (ses
->serverDomain
)
2504 kfree(ses
->serverDomain
);
2508 if (ses
->serverDomain
== NULL
)
2509 goto sesssetup_nomem
;
2510 cifs_strfromUCS_le(ses
->serverDomain
,
2513 bcc_ptr
+= 2 * (len
+ 1);
2514 ses
->serverDomain
[2*len
] = 0;
2515 ses
->serverDomain
[1+(2*len
)] = 0;
2516 } else { /* else no more room so create
2517 dummy domain string */
2518 if (ses
->serverDomain
)
2519 kfree(ses
->serverDomain
);
2521 kzalloc(2, GFP_KERNEL
);
2523 } else { /* no room so create dummy domain
2526 /* if these kcallocs fail not much we
2527 can do, but better to not fail the
2529 kfree(ses
->serverDomain
);
2531 kzalloc(2, GFP_KERNEL
);
2532 kfree(ses
->serverNOS
);
2534 kzalloc(2, GFP_KERNEL
);
2536 } else { /* ASCII */
2537 len
= strnlen(bcc_ptr
, 1024);
2538 if (((long) bcc_ptr
+ len
) - (long)
2539 pByteArea(smb_buffer_response
)
2540 <= BCC(smb_buffer_response
)) {
2541 kfree(ses
->serverOS
);
2542 ses
->serverOS
= kzalloc(len
+ 1,
2544 if (ses
->serverOS
== NULL
)
2545 goto sesssetup_nomem
;
2546 strncpy(ses
->serverOS
, bcc_ptr
, len
);
2549 /* null terminate the string */
2553 len
= strnlen(bcc_ptr
, 1024);
2554 kfree(ses
->serverNOS
);
2555 ses
->serverNOS
= kzalloc(len
+ 1,
2557 if (ses
->serverNOS
== NULL
)
2558 goto sesssetup_nomem
;
2559 strncpy(ses
->serverNOS
, bcc_ptr
, len
);
2564 len
= strnlen(bcc_ptr
, 1024);
2565 if (ses
->serverDomain
)
2566 kfree(ses
->serverDomain
);
2567 ses
->serverDomain
= kzalloc(len
+ 1,
2569 if (ses
->serverDomain
== NULL
)
2570 goto sesssetup_nomem
;
2571 strncpy(ses
->serverDomain
, bcc_ptr
,
2578 ("Variable field of length %d "
2579 "extends beyond end of smb ",
2584 (" Security Blob Length extends beyond "
2589 (" Invalid Word count %d: ",
2590 smb_buffer_response
->WordCount
));
2593 sesssetup_nomem
: /* do not return an error on nomem for the info strings,
2594 since that could make reconnection harder, and
2595 reconnection might be needed to free memory */
2596 cifs_buf_release(smb_buffer
);
2602 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid
,
2603 struct cifsSesInfo
*ses
, bool *pNTLMv2_flag
,
2604 const struct nls_table
*nls_codepage
)
2606 struct smb_hdr
*smb_buffer
;
2607 struct smb_hdr
*smb_buffer_response
;
2608 SESSION_SETUP_ANDX
*pSMB
;
2609 SESSION_SETUP_ANDX
*pSMBr
;
2613 int remaining_words
= 0;
2614 int bytes_returned
= 0;
2616 int SecurityBlobLength
= sizeof(NEGOTIATE_MESSAGE
);
2617 PNEGOTIATE_MESSAGE SecurityBlob
;
2618 PCHALLENGE_MESSAGE SecurityBlob2
;
2619 __u32 negotiate_flags
, capabilities
;
2622 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2625 domain
= ses
->domainName
;
2626 *pNTLMv2_flag
= false;
2627 smb_buffer
= cifs_buf_get();
2628 if (smb_buffer
== NULL
) {
2631 smb_buffer_response
= smb_buffer
;
2632 pSMB
= (SESSION_SETUP_ANDX
*) smb_buffer
;
2633 pSMBr
= (SESSION_SETUP_ANDX
*) smb_buffer_response
;
2635 /* send SMBsessionSetup here */
2636 header_assemble(smb_buffer
, SMB_COM_SESSION_SETUP_ANDX
,
2637 NULL
/* no tCon exists yet */ , 12 /* wct */ );
2639 smb_buffer
->Mid
= GetNextMid(ses
->server
);
2640 pSMB
->req
.hdr
.Flags2
|= SMBFLG2_EXT_SEC
;
2641 pSMB
->req
.hdr
.Flags
|= (SMBFLG_CASELESS
| SMBFLG_CANONICAL_PATH_FORMAT
);
2643 pSMB
->req
.AndXCommand
= 0xFF;
2644 pSMB
->req
.MaxBufferSize
= cpu_to_le16(ses
->server
->maxBuf
);
2645 pSMB
->req
.MaxMpxCount
= cpu_to_le16(ses
->server
->maxReq
);
2647 if (ses
->server
->secMode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
2648 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
2650 capabilities
= CAP_LARGE_FILES
| CAP_NT_SMBS
| CAP_LEVEL_II_OPLOCKS
|
2651 CAP_EXTENDED_SECURITY
;
2652 if (ses
->capabilities
& CAP_UNICODE
) {
2653 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
2654 capabilities
|= CAP_UNICODE
;
2656 if (ses
->capabilities
& CAP_STATUS32
) {
2657 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
2658 capabilities
|= CAP_STATUS32
;
2660 if (ses
->capabilities
& CAP_DFS
) {
2661 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
2662 capabilities
|= CAP_DFS
;
2664 pSMB
->req
.Capabilities
= cpu_to_le32(capabilities
);
2666 bcc_ptr
= (char *) &pSMB
->req
.SecurityBlob
;
2667 SecurityBlob
= (PNEGOTIATE_MESSAGE
) bcc_ptr
;
2668 strncpy(SecurityBlob
->Signature
, NTLMSSP_SIGNATURE
, 8);
2669 SecurityBlob
->MessageType
= NtLmNegotiate
;
2671 NTLMSSP_NEGOTIATE_UNICODE
| NTLMSSP_NEGOTIATE_OEM
|
2672 NTLMSSP_REQUEST_TARGET
| NTLMSSP_NEGOTIATE_NTLM
|
2673 NTLMSSP_NEGOTIATE_56
|
2674 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128
;
2676 negotiate_flags
|= NTLMSSP_NEGOTIATE_SIGN
;
2677 /* if (ntlmv2_support)
2678 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2679 /* setup pointers to domain name and workstation name */
2680 bcc_ptr
+= SecurityBlobLength
;
2682 SecurityBlob
->WorkstationName
.Buffer
= 0;
2683 SecurityBlob
->WorkstationName
.Length
= 0;
2684 SecurityBlob
->WorkstationName
.MaximumLength
= 0;
2686 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2687 along with username on auth request (ie the response to challenge) */
2688 SecurityBlob
->DomainName
.Buffer
= 0;
2689 SecurityBlob
->DomainName
.Length
= 0;
2690 SecurityBlob
->DomainName
.MaximumLength
= 0;
2691 if (ses
->capabilities
& CAP_UNICODE
) {
2692 if ((long) bcc_ptr
% 2) {
2698 cifs_strtoUCS((__le16
*) bcc_ptr
, "Linux version ",
2700 bcc_ptr
+= 2 * bytes_returned
;
2702 cifs_strtoUCS((__le16
*) bcc_ptr
, utsname()->release
, 32,
2704 bcc_ptr
+= 2 * bytes_returned
;
2705 bcc_ptr
+= 2; /* null terminate Linux version */
2707 cifs_strtoUCS((__le16
*) bcc_ptr
, CIFS_NETWORK_OPSYS
,
2709 bcc_ptr
+= 2 * bytes_returned
;
2712 bcc_ptr
+= 2; /* null terminate network opsys string */
2715 bcc_ptr
+= 2; /* null domain */
2716 } else { /* ASCII */
2717 strcpy(bcc_ptr
, "Linux version ");
2718 bcc_ptr
+= strlen("Linux version ");
2719 strcpy(bcc_ptr
, utsname()->release
);
2720 bcc_ptr
+= strlen(utsname()->release
) + 1;
2721 strcpy(bcc_ptr
, CIFS_NETWORK_OPSYS
);
2722 bcc_ptr
+= strlen(CIFS_NETWORK_OPSYS
) + 1;
2723 bcc_ptr
++; /* empty domain field */
2726 SecurityBlob
->NegotiateFlags
= cpu_to_le32(negotiate_flags
);
2727 pSMB
->req
.SecurityBlobLength
= cpu_to_le16(SecurityBlobLength
);
2728 count
= (long) bcc_ptr
- (long) pByteArea(smb_buffer
);
2729 smb_buffer
->smb_buf_length
+= count
;
2730 pSMB
->req
.ByteCount
= cpu_to_le16(count
);
2732 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
,
2733 &bytes_returned
, CIFS_LONG_OP
);
2735 if (smb_buffer_response
->Status
.CifsError
==
2736 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED
))
2740 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2741 } else if ((smb_buffer_response
->WordCount
== 3)
2742 || (smb_buffer_response
->WordCount
== 4)) {
2743 __u16 action
= le16_to_cpu(pSMBr
->resp
.Action
);
2744 __u16 blob_len
= le16_to_cpu(pSMBr
->resp
.SecurityBlobLength
);
2746 if (action
& GUEST_LOGIN
)
2747 cFYI(1, (" Guest login"));
2748 /* Do we want to set anything in SesInfo struct when guest login? */
2750 bcc_ptr
= pByteArea(smb_buffer_response
);
2751 /* response can have either 3 or 4 word count - Samba sends 3 */
2753 SecurityBlob2
= (PCHALLENGE_MESSAGE
) bcc_ptr
;
2754 if (SecurityBlob2
->MessageType
!= NtLmChallenge
) {
2756 ("Unexpected NTLMSSP message type received %d",
2757 SecurityBlob2
->MessageType
));
2759 ses
->Suid
= smb_buffer_response
->Uid
; /* UID left in le format */
2760 cFYI(1, ("UID = %d", ses
->Suid
));
2761 if ((pSMBr
->resp
.hdr
.WordCount
== 3)
2762 || ((pSMBr
->resp
.hdr
.WordCount
== 4)
2764 pSMBr
->resp
.ByteCount
))) {
2766 if (pSMBr
->resp
.hdr
.WordCount
== 4) {
2767 bcc_ptr
+= blob_len
;
2768 cFYI(1, ("Security Blob Length %d",
2772 cFYI(1, ("NTLMSSP Challenge rcvd"));
2774 memcpy(ses
->server
->cryptKey
,
2775 SecurityBlob2
->Challenge
,
2776 CIFS_CRYPTO_KEY_SIZE
);
2777 if (SecurityBlob2
->NegotiateFlags
&
2778 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2
))
2779 *pNTLMv2_flag
= true;
2781 if ((SecurityBlob2
->NegotiateFlags
&
2782 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN
))
2783 || (sign_CIFS_PDUs
> 1))
2784 ses
->server
->secMode
|=
2785 SECMODE_SIGN_REQUIRED
;
2786 if ((SecurityBlob2
->NegotiateFlags
&
2787 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN
)) && (sign_CIFS_PDUs
))
2788 ses
->server
->secMode
|=
2789 SECMODE_SIGN_ENABLED
;
2791 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
) {
2792 if ((long) (bcc_ptr
) % 2) {
2794 (BCC(smb_buffer_response
)
2796 /* Must word align unicode strings */
2801 (smb_buffer_response
) / 2;
2804 UniStrnlen((wchar_t *) bcc_ptr
,
2805 remaining_words
- 1);
2806 /* We look for obvious messed up bcc or strings in response so we do not go off
2807 the end since (at least) WIN2K and Windows XP have a major bug in not null
2808 terminating last Unicode string in response */
2810 kfree(ses
->serverOS
);
2812 kzalloc(2 * (len
+ 1), GFP_KERNEL
);
2813 cifs_strfromUCS_le(ses
->serverOS
,
2817 bcc_ptr
+= 2 * (len
+ 1);
2818 remaining_words
-= len
+ 1;
2819 ses
->serverOS
[2 * len
] = 0;
2820 ses
->serverOS
[1 + (2 * len
)] = 0;
2821 if (remaining_words
> 0) {
2822 len
= UniStrnlen((wchar_t *)
2826 kfree(ses
->serverNOS
);
2828 kzalloc(2 * (len
+ 1),
2830 cifs_strfromUCS_le(ses
->
2836 bcc_ptr
+= 2 * (len
+ 1);
2837 ses
->serverNOS
[2 * len
] = 0;
2840 remaining_words
-= len
+ 1;
2841 if (remaining_words
> 0) {
2842 len
= UniStrnlen((wchar_t *) bcc_ptr
, remaining_words
);
2843 /* last string not always null terminated
2844 (for e.g. for Windows XP & 2000) */
2845 kfree(ses
->serverDomain
);
2857 ses
->serverDomain
[2*len
]
2862 } /* else no more room so create dummy domain string */
2864 kfree(ses
->serverDomain
);
2869 } else { /* no room so create dummy domain and NOS string */
2870 kfree(ses
->serverDomain
);
2872 kzalloc(2, GFP_KERNEL
);
2873 kfree(ses
->serverNOS
);
2875 kzalloc(2, GFP_KERNEL
);
2877 } else { /* ASCII */
2878 len
= strnlen(bcc_ptr
, 1024);
2879 if (((long) bcc_ptr
+ len
) - (long)
2880 pByteArea(smb_buffer_response
)
2881 <= BCC(smb_buffer_response
)) {
2883 kfree(ses
->serverOS
);
2887 strncpy(ses
->serverOS
,
2891 bcc_ptr
[0] = 0; /* null terminate string */
2894 len
= strnlen(bcc_ptr
, 1024);
2895 kfree(ses
->serverNOS
);
2899 strncpy(ses
->serverNOS
, bcc_ptr
, len
);
2904 len
= strnlen(bcc_ptr
, 1024);
2905 kfree(ses
->serverDomain
);
2909 strncpy(ses
->serverDomain
,
2916 ("field of length %d "
2917 "extends beyond end of smb",
2921 cERROR(1, ("Security Blob Length extends beyond"
2925 cERROR(1, ("No session structure passed in."));
2929 (" Invalid Word count %d:",
2930 smb_buffer_response
->WordCount
));
2934 cifs_buf_release(smb_buffer
);
2939 CIFSNTLMSSPAuthSessSetup(unsigned int xid
, struct cifsSesInfo
*ses
,
2940 char *ntlm_session_key
, bool ntlmv2_flag
,
2941 const struct nls_table
*nls_codepage
)
2943 struct smb_hdr
*smb_buffer
;
2944 struct smb_hdr
*smb_buffer_response
;
2945 SESSION_SETUP_ANDX
*pSMB
;
2946 SESSION_SETUP_ANDX
*pSMBr
;
2951 int remaining_words
= 0;
2952 int bytes_returned
= 0;
2954 int SecurityBlobLength
= sizeof(AUTHENTICATE_MESSAGE
);
2955 PAUTHENTICATE_MESSAGE SecurityBlob
;
2956 __u32 negotiate_flags
, capabilities
;
2959 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2962 user
= ses
->userName
;
2963 domain
= ses
->domainName
;
2964 smb_buffer
= cifs_buf_get();
2965 if (smb_buffer
== NULL
) {
2968 smb_buffer_response
= smb_buffer
;
2969 pSMB
= (SESSION_SETUP_ANDX
*)smb_buffer
;
2970 pSMBr
= (SESSION_SETUP_ANDX
*)smb_buffer_response
;
2972 /* send SMBsessionSetup here */
2973 header_assemble(smb_buffer
, SMB_COM_SESSION_SETUP_ANDX
,
2974 NULL
/* no tCon exists yet */ , 12 /* wct */ );
2976 smb_buffer
->Mid
= GetNextMid(ses
->server
);
2977 pSMB
->req
.hdr
.Flags
|= (SMBFLG_CASELESS
| SMBFLG_CANONICAL_PATH_FORMAT
);
2978 pSMB
->req
.hdr
.Flags2
|= SMBFLG2_EXT_SEC
;
2979 pSMB
->req
.AndXCommand
= 0xFF;
2980 pSMB
->req
.MaxBufferSize
= cpu_to_le16(ses
->server
->maxBuf
);
2981 pSMB
->req
.MaxMpxCount
= cpu_to_le16(ses
->server
->maxReq
);
2983 pSMB
->req
.hdr
.Uid
= ses
->Suid
;
2985 if (ses
->server
->secMode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
2986 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
2988 capabilities
= CAP_LARGE_FILES
| CAP_NT_SMBS
| CAP_LEVEL_II_OPLOCKS
|
2989 CAP_EXTENDED_SECURITY
;
2990 if (ses
->capabilities
& CAP_UNICODE
) {
2991 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
2992 capabilities
|= CAP_UNICODE
;
2994 if (ses
->capabilities
& CAP_STATUS32
) {
2995 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
2996 capabilities
|= CAP_STATUS32
;
2998 if (ses
->capabilities
& CAP_DFS
) {
2999 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3000 capabilities
|= CAP_DFS
;
3002 pSMB
->req
.Capabilities
= cpu_to_le32(capabilities
);
3004 bcc_ptr
= (char *)&pSMB
->req
.SecurityBlob
;
3005 SecurityBlob
= (PAUTHENTICATE_MESSAGE
)bcc_ptr
;
3006 strncpy(SecurityBlob
->Signature
, NTLMSSP_SIGNATURE
, 8);
3007 SecurityBlob
->MessageType
= NtLmAuthenticate
;
3008 bcc_ptr
+= SecurityBlobLength
;
3009 negotiate_flags
= NTLMSSP_NEGOTIATE_UNICODE
| NTLMSSP_REQUEST_TARGET
|
3010 NTLMSSP_NEGOTIATE_NTLM
| NTLMSSP_NEGOTIATE_TARGET_INFO
|
3011 0x80000000 | NTLMSSP_NEGOTIATE_128
;
3013 negotiate_flags
|= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN
;
3015 negotiate_flags
|= NTLMSSP_NEGOTIATE_NTLMV2
;
3017 /* setup pointers to domain name and workstation name */
3019 SecurityBlob
->WorkstationName
.Buffer
= 0;
3020 SecurityBlob
->WorkstationName
.Length
= 0;
3021 SecurityBlob
->WorkstationName
.MaximumLength
= 0;
3022 SecurityBlob
->SessionKey
.Length
= 0;
3023 SecurityBlob
->SessionKey
.MaximumLength
= 0;
3024 SecurityBlob
->SessionKey
.Buffer
= 0;
3026 SecurityBlob
->LmChallengeResponse
.Length
= 0;
3027 SecurityBlob
->LmChallengeResponse
.MaximumLength
= 0;
3028 SecurityBlob
->LmChallengeResponse
.Buffer
= 0;
3030 SecurityBlob
->NtChallengeResponse
.Length
=
3031 cpu_to_le16(CIFS_SESS_KEY_SIZE
);
3032 SecurityBlob
->NtChallengeResponse
.MaximumLength
=
3033 cpu_to_le16(CIFS_SESS_KEY_SIZE
);
3034 memcpy(bcc_ptr
, ntlm_session_key
, CIFS_SESS_KEY_SIZE
);
3035 SecurityBlob
->NtChallengeResponse
.Buffer
=
3036 cpu_to_le32(SecurityBlobLength
);
3037 SecurityBlobLength
+= CIFS_SESS_KEY_SIZE
;
3038 bcc_ptr
+= CIFS_SESS_KEY_SIZE
;
3040 if (ses
->capabilities
& CAP_UNICODE
) {
3041 if (domain
== NULL
) {
3042 SecurityBlob
->DomainName
.Buffer
= 0;
3043 SecurityBlob
->DomainName
.Length
= 0;
3044 SecurityBlob
->DomainName
.MaximumLength
= 0;
3046 __u16 ln
= cifs_strtoUCS((__le16
*) bcc_ptr
, domain
, 64,
3049 SecurityBlob
->DomainName
.MaximumLength
=
3051 SecurityBlob
->DomainName
.Buffer
=
3052 cpu_to_le32(SecurityBlobLength
);
3054 SecurityBlobLength
+= ln
;
3055 SecurityBlob
->DomainName
.Length
= cpu_to_le16(ln
);
3058 SecurityBlob
->UserName
.Buffer
= 0;
3059 SecurityBlob
->UserName
.Length
= 0;
3060 SecurityBlob
->UserName
.MaximumLength
= 0;
3062 __u16 ln
= cifs_strtoUCS((__le16
*) bcc_ptr
, user
, 64,
3065 SecurityBlob
->UserName
.MaximumLength
=
3067 SecurityBlob
->UserName
.Buffer
=
3068 cpu_to_le32(SecurityBlobLength
);
3070 SecurityBlobLength
+= ln
;
3071 SecurityBlob
->UserName
.Length
= cpu_to_le16(ln
);
3074 /* SecurityBlob->WorkstationName.Length =
3075 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3076 SecurityBlob->WorkstationName.Length *= 2;
3077 SecurityBlob->WorkstationName.MaximumLength =
3078 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3079 SecurityBlob->WorkstationName.Buffer =
3080 cpu_to_le32(SecurityBlobLength);
3081 bcc_ptr += SecurityBlob->WorkstationName.Length;
3082 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3083 SecurityBlob->WorkstationName.Length =
3084 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3086 if ((long) bcc_ptr
% 2) {
3091 cifs_strtoUCS((__le16
*) bcc_ptr
, "Linux version ",
3093 bcc_ptr
+= 2 * bytes_returned
;
3095 cifs_strtoUCS((__le16
*) bcc_ptr
, utsname()->release
, 32,
3097 bcc_ptr
+= 2 * bytes_returned
;
3098 bcc_ptr
+= 2; /* null term version string */
3100 cifs_strtoUCS((__le16
*) bcc_ptr
, CIFS_NETWORK_OPSYS
,
3102 bcc_ptr
+= 2 * bytes_returned
;
3105 bcc_ptr
+= 2; /* null terminate network opsys string */
3108 bcc_ptr
+= 2; /* null domain */
3109 } else { /* ASCII */
3110 if (domain
== NULL
) {
3111 SecurityBlob
->DomainName
.Buffer
= 0;
3112 SecurityBlob
->DomainName
.Length
= 0;
3113 SecurityBlob
->DomainName
.MaximumLength
= 0;
3116 negotiate_flags
|= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED
;
3117 strncpy(bcc_ptr
, domain
, 63);
3118 ln
= strnlen(domain
, 64);
3119 SecurityBlob
->DomainName
.MaximumLength
=
3121 SecurityBlob
->DomainName
.Buffer
=
3122 cpu_to_le32(SecurityBlobLength
);
3124 SecurityBlobLength
+= ln
;
3125 SecurityBlob
->DomainName
.Length
= cpu_to_le16(ln
);
3128 SecurityBlob
->UserName
.Buffer
= 0;
3129 SecurityBlob
->UserName
.Length
= 0;
3130 SecurityBlob
->UserName
.MaximumLength
= 0;
3133 strncpy(bcc_ptr
, user
, 63);
3134 ln
= strnlen(user
, 64);
3135 SecurityBlob
->UserName
.MaximumLength
= cpu_to_le16(ln
);
3136 SecurityBlob
->UserName
.Buffer
=
3137 cpu_to_le32(SecurityBlobLength
);
3139 SecurityBlobLength
+= ln
;
3140 SecurityBlob
->UserName
.Length
= cpu_to_le16(ln
);
3142 /* BB fill in our workstation name if known BB */
3144 strcpy(bcc_ptr
, "Linux version ");
3145 bcc_ptr
+= strlen("Linux version ");
3146 strcpy(bcc_ptr
, utsname()->release
);
3147 bcc_ptr
+= strlen(utsname()->release
) + 1;
3148 strcpy(bcc_ptr
, CIFS_NETWORK_OPSYS
);
3149 bcc_ptr
+= strlen(CIFS_NETWORK_OPSYS
) + 1;
3150 bcc_ptr
++; /* null domain */
3153 SecurityBlob
->NegotiateFlags
= cpu_to_le32(negotiate_flags
);
3154 pSMB
->req
.SecurityBlobLength
= cpu_to_le16(SecurityBlobLength
);
3155 count
= (long) bcc_ptr
- (long) pByteArea(smb_buffer
);
3156 smb_buffer
->smb_buf_length
+= count
;
3157 pSMB
->req
.ByteCount
= cpu_to_le16(count
);
3159 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
,
3160 &bytes_returned
, CIFS_LONG_OP
);
3162 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3163 } else if ((smb_buffer_response
->WordCount
== 3) ||
3164 (smb_buffer_response
->WordCount
== 4)) {
3165 __u16 action
= le16_to_cpu(pSMBr
->resp
.Action
);
3166 __u16 blob_len
= le16_to_cpu(pSMBr
->resp
.SecurityBlobLength
);
3167 if (action
& GUEST_LOGIN
)
3168 cFYI(1, (" Guest login")); /* BB Should we set anything
3169 in SesInfo struct ? */
3170 /* if (SecurityBlob2->MessageType != NtLm??) {
3171 cFYI("Unexpected message type on auth response is %d"));
3176 ("Check challenge UID %d vs auth response UID %d",
3177 ses
->Suid
, smb_buffer_response
->Uid
));
3178 /* UID left in wire format */
3179 ses
->Suid
= smb_buffer_response
->Uid
;
3180 bcc_ptr
= pByteArea(smb_buffer_response
);
3181 /* response can have either 3 or 4 word count - Samba sends 3 */
3182 if ((pSMBr
->resp
.hdr
.WordCount
== 3)
3183 || ((pSMBr
->resp
.hdr
.WordCount
== 4)
3185 pSMBr
->resp
.ByteCount
))) {
3186 if (pSMBr
->resp
.hdr
.WordCount
== 4) {
3190 ("Security Blob Length %d ",
3195 ("NTLMSSP response to Authenticate "));
3197 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
) {
3198 if ((long) (bcc_ptr
) % 2) {
3200 (BCC(smb_buffer_response
)
3202 bcc_ptr
++; /* Unicode strings must be word aligned */
3204 remaining_words
= BCC(smb_buffer_response
) / 2;
3206 len
= UniStrnlen((wchar_t *) bcc_ptr
,
3207 remaining_words
- 1);
3208 /* We look for obvious messed up bcc or strings in response so we do not go off
3209 the end since (at least) WIN2K and Windows XP have a major bug in not null
3210 terminating last Unicode string in response */
3212 kfree(ses
->serverOS
);
3214 kzalloc(2 * (len
+ 1), GFP_KERNEL
);
3215 cifs_strfromUCS_le(ses
->serverOS
,
3219 bcc_ptr
+= 2 * (len
+ 1);
3220 remaining_words
-= len
+ 1;
3221 ses
->serverOS
[2 * len
] = 0;
3222 ses
->serverOS
[1 + (2 * len
)] = 0;
3223 if (remaining_words
> 0) {
3224 len
= UniStrnlen((wchar_t *)
3228 kfree(ses
->serverNOS
);
3230 kzalloc(2 * (len
+ 1),
3232 cifs_strfromUCS_le(ses
->
3238 bcc_ptr
+= 2 * (len
+ 1);
3239 ses
->serverNOS
[2 * len
] = 0;
3240 ses
->serverNOS
[1+(2*len
)] = 0;
3241 remaining_words
-= len
+ 1;
3242 if (remaining_words
> 0) {
3243 len
= UniStrnlen((wchar_t *) bcc_ptr
, remaining_words
);
3244 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3245 if (ses
->serverDomain
)
3246 kfree(ses
->serverDomain
);
3271 } /* else no more room so create dummy domain string */
3273 if (ses
->serverDomain
)
3274 kfree(ses
->serverDomain
);
3275 ses
->serverDomain
= kzalloc(2,GFP_KERNEL
);
3277 } else { /* no room so create dummy domain and NOS string */
3278 if (ses
->serverDomain
)
3279 kfree(ses
->serverDomain
);
3280 ses
->serverDomain
= kzalloc(2, GFP_KERNEL
);
3281 kfree(ses
->serverNOS
);
3282 ses
->serverNOS
= kzalloc(2, GFP_KERNEL
);
3284 } else { /* ASCII */
3285 len
= strnlen(bcc_ptr
, 1024);
3286 if (((long) bcc_ptr
+ len
) -
3287 (long) pByteArea(smb_buffer_response
)
3288 <= BCC(smb_buffer_response
)) {
3290 kfree(ses
->serverOS
);
3291 ses
->serverOS
= kzalloc(len
+ 1, GFP_KERNEL
);
3292 strncpy(ses
->serverOS
,bcc_ptr
, len
);
3295 bcc_ptr
[0] = 0; /* null terminate the string */
3298 len
= strnlen(bcc_ptr
, 1024);
3299 kfree(ses
->serverNOS
);
3300 ses
->serverNOS
= kzalloc(len
+1,
3302 strncpy(ses
->serverNOS
,
3308 len
= strnlen(bcc_ptr
, 1024);
3309 if (ses
->serverDomain
)
3310 kfree(ses
->serverDomain
);
3314 strncpy(ses
->serverDomain
,
3320 cFYI(1, ("field of length %d "
3321 "extends beyond end of smb ",
3325 cERROR(1, ("Security Blob extends beyond end "
3329 cERROR(1, ("No session structure passed in."));
3332 cERROR(1, ("Invalid Word count %d: ",
3333 smb_buffer_response
->WordCount
));
3337 cifs_buf_release(smb_buffer
);
3343 CIFSTCon(unsigned int xid
, struct cifsSesInfo
*ses
,
3344 const char *tree
, struct cifsTconInfo
*tcon
,
3345 const struct nls_table
*nls_codepage
)
3347 struct smb_hdr
*smb_buffer
;
3348 struct smb_hdr
*smb_buffer_response
;
3351 unsigned char *bcc_ptr
;
3359 smb_buffer
= cifs_buf_get();
3360 if (smb_buffer
== NULL
) {
3363 smb_buffer_response
= smb_buffer
;
3365 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3366 NULL
/*no tid */ , 4 /*wct */ );
3368 smb_buffer
->Mid
= GetNextMid(ses
->server
);
3369 smb_buffer
->Uid
= ses
->Suid
;
3370 pSMB
= (TCONX_REQ
*) smb_buffer
;
3371 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3373 pSMB
->AndXCommand
= 0xFF;
3374 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3375 bcc_ptr
= &pSMB
->Password
[0];
3376 if ((ses
->server
->secMode
) & SECMODE_USER
) {
3377 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3378 *bcc_ptr
= 0; /* password is null byte */
3379 bcc_ptr
++; /* skip password */
3380 /* already aligned so no need to do it below */
3382 pSMB
->PasswordLength
= cpu_to_le16(CIFS_SESS_KEY_SIZE
);
3383 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3384 specified as required (when that support is added to
3385 the vfs in the future) as only NTLM or the much
3386 weaker LANMAN (which we do not send by default) is accepted
3387 by Samba (not sure whether other servers allow
3388 NTLMv2 password here) */
3389 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3390 if ((extended_security
& CIFSSEC_MAY_LANMAN
) &&
3391 (ses
->server
->secType
== LANMAN
))
3392 calc_lanman_hash(ses
, bcc_ptr
);
3394 #endif /* CIFS_WEAK_PW_HASH */
3395 SMBNTencrypt(ses
->password
,
3396 ses
->server
->cryptKey
,
3399 bcc_ptr
+= CIFS_SESS_KEY_SIZE
;
3400 if (ses
->capabilities
& CAP_UNICODE
) {
3401 /* must align unicode strings */
3402 *bcc_ptr
= 0; /* null byte password */
3407 if (ses
->server
->secMode
&
3408 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
3409 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3411 if (ses
->capabilities
& CAP_STATUS32
) {
3412 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3414 if (ses
->capabilities
& CAP_DFS
) {
3415 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3417 if (ses
->capabilities
& CAP_UNICODE
) {
3418 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3420 cifs_strtoUCS((__le16
*) bcc_ptr
, tree
,
3421 6 /* max utf8 char length in bytes */ *
3422 (/* server len*/ + 256 /* share len */), nls_codepage
);
3423 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3424 bcc_ptr
+= 2; /* skip trailing null */
3425 } else { /* ASCII */
3426 strcpy(bcc_ptr
, tree
);
3427 bcc_ptr
+= strlen(tree
) + 1;
3429 strcpy(bcc_ptr
, "?????");
3430 bcc_ptr
+= strlen("?????");
3432 count
= bcc_ptr
- &pSMB
->Password
[0];
3433 pSMB
->hdr
.smb_buf_length
+= count
;
3434 pSMB
->ByteCount
= cpu_to_le16(count
);
3436 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3439 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3440 /* above now done in SendReceive */
3441 if ((rc
== 0) && (tcon
!= NULL
)) {
3442 tcon
->tidStatus
= CifsGood
;
3443 tcon
->tid
= smb_buffer_response
->Tid
;
3444 bcc_ptr
= pByteArea(smb_buffer_response
);
3445 length
= strnlen(bcc_ptr
, BCC(smb_buffer_response
) - 2);
3446 /* skip service field (NB: this field is always ASCII) */
3448 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3449 (bcc_ptr
[2] == 'C')) {
3450 cFYI(1, ("IPC connection"));
3453 } else if (length
== 2) {
3454 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3455 /* the most common case */
3456 cFYI(1, ("disk share connection"));
3459 bcc_ptr
+= length
+ 1;
3460 strncpy(tcon
->treeName
, tree
, MAX_TREE_SIZE
);
3461 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
) {
3462 length
= UniStrnlen((wchar_t *) bcc_ptr
, 512);
3463 if ((bcc_ptr
+ (2 * length
)) -
3464 pByteArea(smb_buffer_response
) <=
3465 BCC(smb_buffer_response
)) {
3466 kfree(tcon
->nativeFileSystem
);
3467 tcon
->nativeFileSystem
=
3468 kzalloc(length
+ 2, GFP_KERNEL
);
3469 if (tcon
->nativeFileSystem
)
3471 tcon
->nativeFileSystem
,
3473 length
, nls_codepage
);
3474 bcc_ptr
+= 2 * length
;
3475 bcc_ptr
[0] = 0; /* null terminate the string */
3479 /* else do not bother copying these information fields*/
3481 length
= strnlen(bcc_ptr
, 1024);
3482 if ((bcc_ptr
+ length
) -
3483 pByteArea(smb_buffer_response
) <=
3484 BCC(smb_buffer_response
)) {
3485 kfree(tcon
->nativeFileSystem
);
3486 tcon
->nativeFileSystem
=
3487 kzalloc(length
+ 1, GFP_KERNEL
);
3488 if (tcon
->nativeFileSystem
)
3489 strncpy(tcon
->nativeFileSystem
, bcc_ptr
,
3492 /* else do not bother copying these information fields*/
3494 if ((smb_buffer_response
->WordCount
== 3) ||
3495 (smb_buffer_response
->WordCount
== 7))
3496 /* field is in same location */
3497 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3500 cFYI(1, ("Tcon flags: 0x%x ", tcon
->Flags
));
3501 } else if ((rc
== 0) && tcon
== NULL
) {
3502 /* all we need to save for IPC$ connection */
3503 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3506 cifs_buf_release(smb_buffer
);
3511 cifs_umount(struct super_block
*sb
, struct cifs_sb_info
*cifs_sb
)
3515 struct cifsSesInfo
*ses
= NULL
;
3516 struct task_struct
*cifsd_task
;
3521 if (cifs_sb
->tcon
) {
3522 ses
= cifs_sb
->tcon
->ses
; /* save ptr to ses before delete tcon!*/
3523 rc
= CIFSSMBTDis(xid
, cifs_sb
->tcon
);
3528 DeleteTconOplockQEntries(cifs_sb
->tcon
);
3529 tconInfoFree(cifs_sb
->tcon
);
3530 if ((ses
) && (ses
->server
)) {
3531 /* save off task so we do not refer to ses later */
3532 cifsd_task
= ses
->server
->tsk
;
3533 cFYI(1, ("About to do SMBLogoff "));
3534 rc
= CIFSSMBLogoff(xid
, ses
);
3538 } else if (rc
== -ESHUTDOWN
) {
3539 cFYI(1, ("Waking up socket by sending signal"));
3541 force_sig(SIGKILL
, cifsd_task
);
3542 kthread_stop(cifsd_task
);
3545 } /* else - we have an smb session
3546 left on this socket do not kill cifsd */
3548 cFYI(1, ("No session or bad tcon"));
3551 cifs_sb
->tcon
= NULL
;
3552 tmp
= cifs_sb
->prepath
;
3553 cifs_sb
->prepathlen
= 0;
3554 cifs_sb
->prepath
= NULL
;
3563 int cifs_setup_session(unsigned int xid
, struct cifsSesInfo
*pSesInfo
,
3564 struct nls_table
*nls_info
)
3567 char ntlm_session_key
[CIFS_SESS_KEY_SIZE
];
3568 bool ntlmv2_flag
= false;
3571 /* what if server changes its buffer size after dropping the session? */
3572 if (pSesInfo
->server
->maxBuf
== 0) /* no need to send on reconnect */ {
3573 rc
= CIFSSMBNegotiate(xid
, pSesInfo
);
3574 if (rc
== -EAGAIN
) /* retry only once on 1st time connection */ {
3575 rc
= CIFSSMBNegotiate(xid
, pSesInfo
);
3580 spin_lock(&GlobalMid_Lock
);
3581 if (pSesInfo
->server
->tcpStatus
!= CifsExiting
)
3582 pSesInfo
->server
->tcpStatus
= CifsGood
;
3585 spin_unlock(&GlobalMid_Lock
);
3591 pSesInfo
->flags
= 0;
3592 pSesInfo
->capabilities
= pSesInfo
->server
->capabilities
;
3593 if (linuxExtEnabled
== 0)
3594 pSesInfo
->capabilities
&= (~CAP_UNIX
);
3595 /* pSesInfo->sequence_number = 0;*/
3597 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3598 pSesInfo
->server
->secMode
,
3599 pSesInfo
->server
->capabilities
,
3600 pSesInfo
->server
->timeAdj
));
3601 if (experimEnabled
< 2)
3602 rc
= CIFS_SessSetup(xid
, pSesInfo
,
3603 first_time
, nls_info
);
3604 else if (extended_security
3605 && (pSesInfo
->capabilities
3606 & CAP_EXTENDED_SECURITY
)
3607 && (pSesInfo
->server
->secType
== NTLMSSP
)) {
3609 } else if (extended_security
3610 && (pSesInfo
->capabilities
& CAP_EXTENDED_SECURITY
)
3611 && (pSesInfo
->server
->secType
== RawNTLMSSP
)) {
3612 cFYI(1, ("NTLMSSP sesssetup"));
3613 rc
= CIFSNTLMSSPNegotiateSessSetup(xid
,
3620 cFYI(1, ("more secure NTLM ver2 hash"));
3621 if (CalcNTLMv2_partial_mac_key(pSesInfo
,
3626 v2_response
= kmalloc(16 + 64 /* blob */, GFP_KERNEL
);
3628 CalcNTLMv2_response(pSesInfo
,
3631 cifs_calculate_ntlmv2_mac_key(
3632 pSesInfo->server->mac_signing_key,
3633 response, ntlm_session_key,*/
3635 /* BB Put dummy sig in SessSetup PDU? */
3642 SMBNTencrypt(pSesInfo
->password
,
3643 pSesInfo
->server
->cryptKey
,
3647 cifs_calculate_mac_key(
3648 &pSesInfo
->server
->mac_signing_key
,
3650 pSesInfo
->password
);
3652 /* for better security the weaker lanman hash not sent
3653 in AuthSessSetup so we no longer calculate it */
3655 rc
= CIFSNTLMSSPAuthSessSetup(xid
,
3661 } else { /* old style NTLM 0.12 session setup */
3662 SMBNTencrypt(pSesInfo
->password
,
3663 pSesInfo
->server
->cryptKey
,
3667 cifs_calculate_mac_key(
3668 &pSesInfo
->server
->mac_signing_key
,
3669 ntlm_session_key
, pSesInfo
->password
);
3671 rc
= CIFSSessSetup(xid
, pSesInfo
,
3672 ntlm_session_key
, nls_info
);
3675 cERROR(1, ("Send error in SessSetup = %d", rc
));
3677 cFYI(1, ("CIFS Session Established successfully"));
3678 pSesInfo
->status
= CifsGood
;