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 */
80 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
83 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool remap:1; /* set to remap seven reserved chars in filenames */
86 bool posix_paths:1; /* unset to not ask for posix pathnames. */
89 bool nullauth:1; /* attempt to authenticate with null user */
90 bool nocase:1; /* request case insensitive filenames */
91 bool nobrl:1; /* disable sending byte range locks to srv */
92 bool seal:1; /* request transport encryption on share */
93 bool nodfs:1; /* Do not request DFS, even if available */
94 bool local_lease:1; /* check leases only on local system, not remote */
100 unsigned short int port;
104 static int ipv4_connect(struct sockaddr_in *psin_server,
105 struct socket **csocket,
107 char *server_netb_name,
109 bool nosndbuf); /* ipv6 never set sndbuf size */
110 static int ipv6_connect(struct sockaddr_in6 *psin_server,
111 struct socket **csocket, bool noblocksnd);
115 * cifs tcp session reconnection
117 * mark tcp session as reconnecting so temporarily locked
118 * mark all smb sessions as reconnecting for tcp session
119 * reconnect tcp session
120 * wake up waiters on reconnection? - (not needed currently)
124 cifs_reconnect(struct TCP_Server_Info *server)
127 struct list_head *tmp, *tmp2;
128 struct cifsSesInfo *ses;
129 struct cifsTconInfo *tcon;
130 struct mid_q_entry *mid_entry;
132 spin_lock(&GlobalMid_Lock);
133 if (server->tcpStatus == CifsExiting) {
134 /* the demux thread will exit normally
135 next time through the loop */
136 spin_unlock(&GlobalMid_Lock);
139 server->tcpStatus = CifsNeedReconnect;
140 spin_unlock(&GlobalMid_Lock);
143 cFYI(1, ("Reconnecting tcp session"));
145 /* before reconnecting the tcp session, mark the smb session (uid)
146 and the tid bad so they are not used until reconnected */
147 read_lock(&cifs_tcp_ses_lock);
148 list_for_each(tmp, &server->smb_ses_list) {
149 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
150 ses->need_reconnect = true;
152 list_for_each(tmp2, &ses->tcon_list) {
153 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
154 tcon->need_reconnect = true;
157 read_unlock(&cifs_tcp_ses_lock);
158 /* do not want to be sending data on a socket we are freeing */
159 down(&server->tcpSem);
160 if (server->ssocket) {
161 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
162 server->ssocket->flags));
163 kernel_sock_shutdown(server->ssocket, SHUT_WR);
164 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
165 server->ssocket->state,
166 server->ssocket->flags));
167 sock_release(server->ssocket);
168 server->ssocket = NULL;
171 spin_lock(&GlobalMid_Lock);
172 list_for_each(tmp, &server->pending_mid_q) {
173 mid_entry = list_entry(tmp, struct
176 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
177 /* Mark other intransit requests as needing
178 retry so we do not immediately mark the
179 session bad again (ie after we reconnect
180 below) as they timeout too */
181 mid_entry->midState = MID_RETRY_NEEDED;
184 spin_unlock(&GlobalMid_Lock);
187 while ((server->tcpStatus != CifsExiting) &&
188 (server->tcpStatus != CifsGood)) {
190 if (server->addr.sockAddr6.sin6_family == AF_INET6) {
191 rc = ipv6_connect(&server->addr.sockAddr6,
192 &server->ssocket, server->noautotune);
194 rc = ipv4_connect(&server->addr.sockAddr,
196 server->workstation_RFC1001_name,
197 server->server_RFC1001_name,
198 server->noblocksnd, server->noautotune);
201 cFYI(1, ("reconnect error %d", rc));
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
206 if (server->tcpStatus != CifsExiting)
207 server->tcpStatus = CifsGood;
208 server->sequence_number = 0;
209 spin_unlock(&GlobalMid_Lock);
210 /* atomic_set(&server->inFlight,0);*/
211 wake_up(&server->response_q);
219 0 not a transact2, or all data present
220 >0 transact2 with that much data missing
221 -EINVAL = invalid transact2
224 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
226 struct smb_t2_rsp *pSMBt;
228 int data_in_this_rsp;
231 if (pSMB->Command != SMB_COM_TRANSACTION2)
234 /* check for plausible wct, bcc and t2 data and parm sizes */
235 /* check for parm and data offset going beyond end of smb */
236 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
237 cFYI(1, ("invalid transact2 word count"));
241 pSMBt = (struct smb_t2_rsp *)pSMB;
243 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
244 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
246 remaining = total_data_size - data_in_this_rsp;
250 else if (remaining < 0) {
251 cFYI(1, ("total data %d smaller than data in frame %d",
252 total_data_size, data_in_this_rsp));
255 cFYI(1, ("missing %d bytes from transact2, check next response",
257 if (total_data_size > maxBufSize) {
258 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
259 total_data_size, maxBufSize));
266 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
268 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
269 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
274 char *data_area_of_target;
275 char *data_area_of_buf2;
278 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
280 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
281 cFYI(1, ("total data size of primary and secondary t2 differ"));
284 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
286 remaining = total_data_size - total_in_buf;
291 if (remaining == 0) /* nothing to do, ignore */
294 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
295 if (remaining < total_in_buf2) {
296 cFYI(1, ("transact2 2nd response contains too much data"));
299 /* find end of first SMB data area */
300 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
301 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
302 /* validate target area */
304 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
305 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
307 data_area_of_target += total_in_buf;
309 /* copy second buffer into end of first buffer */
310 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
311 total_in_buf += total_in_buf2;
312 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
313 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
314 byte_count += total_in_buf2;
315 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
317 byte_count = pTargetSMB->smb_buf_length;
318 byte_count += total_in_buf2;
320 /* BB also add check that we are not beyond maximum buffer size */
322 pTargetSMB->smb_buf_length = byte_count;
324 if (remaining == total_in_buf2) {
325 cFYI(1, ("found the last secondary response"));
326 return 0; /* we are done */
327 } else /* more responses to go */
333 cifs_demultiplex_thread(struct TCP_Server_Info *server)
336 unsigned int pdu_length, total_read;
337 struct smb_hdr *smb_buffer = NULL;
338 struct smb_hdr *bigbuf = NULL;
339 struct smb_hdr *smallbuf = NULL;
340 struct msghdr smb_msg;
342 struct socket *csocket = server->ssocket;
343 struct list_head *tmp;
344 struct cifsSesInfo *ses;
345 struct task_struct *task_to_wake = NULL;
346 struct mid_q_entry *mid_entry;
348 bool isLargeBuf = false;
352 current->flags |= PF_MEMALLOC;
353 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
355 length = atomic_inc_return(&tcpSesAllocCount);
357 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
361 while (server->tcpStatus != CifsExiting) {
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 (server->tcpStatus == CifsExiting) {
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 */
414 if (pdu_length < 4) {
415 iov.iov_base = (4 - pdu_length) +
417 iov.iov_len = pdu_length;
418 smb_msg.msg_control = NULL;
419 smb_msg.msg_controllen = 0;
423 } else if (length <= 0) {
424 if (server->tcpStatus == CifsNew) {
425 cFYI(1, ("tcp session abend after SMBnegprot"));
426 /* some servers kill the TCP session rather than
427 returning an SMB negprot error, in which
428 case reconnecting here is not going to help,
429 and so simply return error to mount */
432 if (!try_to_freeze() && (length == -EINTR)) {
433 cFYI(1, ("cifsd thread killed"));
436 cFYI(1, ("Reconnect after unexpected peek error %d",
438 cifs_reconnect(server);
439 csocket = server->ssocket;
440 wake_up(&server->response_q);
442 } else if (length < pdu_length) {
443 cFYI(1, ("requested %d bytes but only got %d bytes",
444 pdu_length, length));
445 pdu_length -= length;
450 /* The right amount was read from socket - 4 bytes */
451 /* so we can now interpret the length field */
453 /* the first byte big endian of the length field,
454 is actually not part of the length but the type
455 with the most common, zero, as regular data */
456 temp = *((char *) smb_buffer);
458 /* Note that FC 1001 length is big endian on the wire,
459 but we convert it here so it is always manipulated
460 as host byte order */
461 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
462 smb_buffer->smb_buf_length = pdu_length;
464 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
466 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
468 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
469 cFYI(1, ("Good RFC 1002 session rsp"));
471 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
472 /* we get this from Windows 98 instead of
473 an error on SMB negprot response */
474 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
476 if (server->tcpStatus == CifsNew) {
477 /* if nack on negprot (rather than
478 ret of smb negprot error) reconnecting
479 not going to help, ret error to mount */
482 /* give server a second to
483 clean up before reconnect attempt */
485 /* always try 445 first on reconnect
486 since we get NACK on some if we ever
487 connected to port 139 (the NACK is
488 since we do not begin with RFC1001
489 session initialize frame) */
490 server->addr.sockAddr.sin_port =
492 cifs_reconnect(server);
493 csocket = server->ssocket;
494 wake_up(&server->response_q);
497 } else if (temp != (char) 0) {
498 cERROR(1, ("Unknown RFC 1002 frame"));
499 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
501 cifs_reconnect(server);
502 csocket = server->ssocket;
506 /* else we have an SMB response */
507 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
508 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
509 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
510 length, pdu_length+4));
511 cifs_reconnect(server);
512 csocket = server->ssocket;
513 wake_up(&server->response_q);
520 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
522 memcpy(bigbuf, smallbuf, 4);
526 iov.iov_base = 4 + (char *)smb_buffer;
527 iov.iov_len = pdu_length;
528 for (total_read = 0; total_read < pdu_length;
529 total_read += length) {
530 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
531 pdu_length - total_read, 0);
532 if ((server->tcpStatus == CifsExiting) ||
533 (length == -EINTR)) {
537 } else if (server->tcpStatus == CifsNeedReconnect) {
538 cifs_reconnect(server);
539 csocket = server->ssocket;
540 /* Reconnect wakes up rspns q */
541 /* Now we will reread sock */
544 } else if ((length == -ERESTARTSYS) ||
545 (length == -EAGAIN)) {
546 msleep(1); /* minimum sleep to prevent looping,
547 allowing socket to clear and app
548 threads to set tcpStatus
549 CifsNeedReconnect if server hung*/
552 } else if (length <= 0) {
553 cERROR(1, ("Received no data, expecting %d",
554 pdu_length - total_read));
555 cifs_reconnect(server);
556 csocket = server->ssocket;
563 else if (reconnect == 1)
566 length += 4; /* account for rfc1002 hdr */
569 dump_smb(smb_buffer, length);
570 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
571 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
577 spin_lock(&GlobalMid_Lock);
578 list_for_each(tmp, &server->pending_mid_q) {
579 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
581 if ((mid_entry->mid == smb_buffer->Mid) &&
582 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
583 (mid_entry->command == smb_buffer->Command)) {
584 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
585 /* We have a multipart transact2 resp */
587 if (mid_entry->resp_buf) {
588 /* merge response - fix up 1st*/
589 if (coalesce_t2(smb_buffer,
590 mid_entry->resp_buf)) {
591 mid_entry->multiRsp =
595 /* all parts received */
596 mid_entry->multiEnd =
602 cERROR(1,("1st trans2 resp needs bigbuf"));
603 /* BB maybe we can fix this up, switch
604 to already allocated large buffer? */
606 /* Have first buffer */
607 mid_entry->resp_buf =
609 mid_entry->largeBuf =
616 mid_entry->resp_buf = smb_buffer;
617 mid_entry->largeBuf = isLargeBuf;
619 task_to_wake = mid_entry->tsk;
620 mid_entry->midState = MID_RESPONSE_RECEIVED;
621 #ifdef CONFIG_CIFS_STATS2
622 mid_entry->when_received = jiffies;
624 /* so we do not time out requests to server
625 which is still responding (since server could
626 be busy but not dead) */
627 server->lstrp = jiffies;
631 spin_unlock(&GlobalMid_Lock);
633 /* Was previous buf put in mpx struct for multi-rsp? */
635 /* smb buffer will be freed by user thread */
641 wake_up_process(task_to_wake);
642 } else if (!is_valid_oplock_break(smb_buffer, server) &&
644 cERROR(1, ("No task to wake, unknown frame received! "
645 "NumMids %d", midCount.counter));
646 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
647 sizeof(struct smb_hdr));
648 #ifdef CONFIG_CIFS_DEBUG2
649 cifs_dump_detail(smb_buffer);
650 cifs_dump_mids(server);
651 #endif /* CIFS_DEBUG2 */
654 } /* end while !EXITING */
656 /* take it off the list, if it's not already */
657 write_lock(&cifs_tcp_ses_lock);
658 list_del_init(&server->tcp_ses_list);
659 write_unlock(&cifs_tcp_ses_lock);
661 spin_lock(&GlobalMid_Lock);
662 server->tcpStatus = CifsExiting;
663 spin_unlock(&GlobalMid_Lock);
664 wake_up_all(&server->response_q);
666 /* check if we have blocked requests that need to free */
667 /* Note that cifs_max_pending is normally 50, but
668 can be set at module install time to as little as two */
669 spin_lock(&GlobalMid_Lock);
670 if (atomic_read(&server->inFlight) >= cifs_max_pending)
671 atomic_set(&server->inFlight, cifs_max_pending - 1);
672 /* We do not want to set the max_pending too low or we
673 could end up with the counter going negative */
674 spin_unlock(&GlobalMid_Lock);
675 /* Although there should not be any requests blocked on
676 this queue it can not hurt to be paranoid and try to wake up requests
677 that may haven been blocked when more than 50 at time were on the wire
678 to the same server - they now will see the session is in exit state
679 and get out of SendReceive. */
680 wake_up_all(&server->request_q);
681 /* give those requests time to exit */
684 if (server->ssocket) {
685 sock_release(csocket);
686 server->ssocket = NULL;
688 /* buffer usuallly freed in free_mid - need to free it here on exit */
689 cifs_buf_release(bigbuf);
690 if (smallbuf) /* no sense logging a debug message if NULL */
691 cifs_small_buf_release(smallbuf);
694 * BB: we shouldn't have to do any of this. It shouldn't be
695 * possible to exit from the thread with active SMB sessions
697 read_lock(&cifs_tcp_ses_lock);
698 if (list_empty(&server->pending_mid_q)) {
699 /* loop through server session structures attached to this and
701 list_for_each(tmp, &server->smb_ses_list) {
702 ses = list_entry(tmp, struct cifsSesInfo,
704 ses->status = CifsExiting;
707 read_unlock(&cifs_tcp_ses_lock);
709 /* although we can not zero the server struct pointer yet,
710 since there are active requests which may depnd on them,
711 mark the corresponding SMB sessions as exiting too */
712 list_for_each(tmp, &server->smb_ses_list) {
713 ses = list_entry(tmp, struct cifsSesInfo,
715 ses->status = CifsExiting;
718 spin_lock(&GlobalMid_Lock);
719 list_for_each(tmp, &server->pending_mid_q) {
720 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
721 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
722 cFYI(1, ("Clearing Mid 0x%x - waking up ",
724 task_to_wake = mid_entry->tsk;
726 wake_up_process(task_to_wake);
729 spin_unlock(&GlobalMid_Lock);
730 read_unlock(&cifs_tcp_ses_lock);
731 /* 1/8th of sec is more than enough time for them to exit */
735 if (!list_empty(&server->pending_mid_q)) {
736 /* mpx threads have not exited yet give them
737 at least the smb send timeout time for long ops */
738 /* due to delays on oplock break requests, we need
739 to wait at least 45 seconds before giving up
740 on a request getting a response and going ahead
742 cFYI(1, ("Wait for exit from demultiplex thread"));
744 /* if threads still have not exited they are probably never
745 coming home not much else we can do but free the memory */
748 /* last chance to mark ses pointers invalid
749 if there are any pointing to this (e.g
750 if a crazy root user tried to kill cifsd
751 kernel thread explicitly this might happen) */
752 /* BB: This shouldn't be necessary, see above */
753 read_lock(&cifs_tcp_ses_lock);
754 list_for_each(tmp, &server->smb_ses_list) {
755 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
758 read_unlock(&cifs_tcp_ses_lock);
760 kfree(server->hostname);
761 task_to_wake = xchg(&server->tsk, NULL);
764 length = atomic_dec_return(&tcpSesAllocCount);
766 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
769 /* if server->tsk was NULL then wait for a signal before exiting */
771 set_current_state(TASK_INTERRUPTIBLE);
772 while (!signal_pending(current)) {
774 set_current_state(TASK_INTERRUPTIBLE);
776 set_current_state(TASK_RUNNING);
782 /* extract the host portion of the UNC string */
784 extract_hostname(const char *unc)
790 /* skip double chars at beginning of string */
791 /* BB: check validity of these bytes? */
794 /* delimiter between hostname and sharename is always '\\' now */
795 delim = strchr(src, '\\');
797 return ERR_PTR(-EINVAL);
800 dst = kmalloc((len + 1), GFP_KERNEL);
802 return ERR_PTR(-ENOMEM);
804 memcpy(dst, src, len);
811 cifs_parse_mount_options(char *options, const char *devname,
816 unsigned int temp_len, i, j;
822 if (Local_System_Name[0] != 0)
823 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
825 char *nodename = utsname()->nodename;
826 int n = strnlen(nodename, 15);
827 memset(vol->source_rfc1001_name, 0x20, 15);
828 for (i = 0; i < n; i++) {
829 /* does not have to be perfect mapping since field is
830 informational, only used for servers that do not support
831 port 445 and it can be overridden at mount time */
832 vol->source_rfc1001_name[i] = toupper(nodename[i]);
835 vol->source_rfc1001_name[15] = 0;
836 /* null target name indicates to use *SMBSERVR default called name
837 if we end up sending RFC1001 session initialize */
838 vol->target_rfc1001_name[0] = 0;
839 vol->linux_uid = current->uid; /* current->euid instead? */
840 vol->linux_gid = current->gid;
841 vol->dir_mode = S_IRWXUGO;
842 /* 2767 perms indicate mandatory locking support */
843 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
845 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
847 /* default is always to request posix paths. */
848 vol->posix_paths = 1;
853 if (strncmp(options, "sep=", 4) == 0) {
854 if (options[4] != 0) {
855 separator[0] = options[4];
858 cFYI(1, ("Null separator not allowed"));
862 while ((data = strsep(&options, separator)) != NULL) {
865 if ((value = strchr(data, '=')) != NULL)
868 /* Have to parse this before we parse for "user" */
869 if (strnicmp(data, "user_xattr", 10) == 0) {
871 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
873 } else if (strnicmp(data, "user", 4) == 0) {
876 "CIFS: invalid or missing username\n");
877 return 1; /* needs_arg; */
878 } else if (!*value) {
879 /* null user, ie anonymous, authentication */
882 if (strnlen(value, 200) < 200) {
883 vol->username = value;
885 printk(KERN_WARNING "CIFS: username too long\n");
888 } else if (strnicmp(data, "pass", 4) == 0) {
890 vol->password = NULL;
892 } else if (value[0] == 0) {
893 /* check if string begins with double comma
894 since that would mean the password really
895 does start with a comma, and would not
896 indicate an empty string */
897 if (value[1] != separator[0]) {
898 vol->password = NULL;
902 temp_len = strlen(value);
903 /* removed password length check, NTLM passwords
904 can be arbitrarily long */
906 /* if comma in password, the string will be
907 prematurely null terminated. Commas in password are
908 specified across the cifs mount interface by a double
909 comma ie ,, and a comma used as in other cases ie ','
910 as a parameter delimiter/separator is single and due
911 to the strsep above is temporarily zeroed. */
913 /* NB: password legally can have multiple commas and
914 the only illegal character in a password is null */
916 if ((value[temp_len] == 0) &&
917 (value[temp_len+1] == separator[0])) {
919 value[temp_len] = separator[0];
920 temp_len += 2; /* move after second comma */
921 while (value[temp_len] != 0) {
922 if (value[temp_len] == separator[0]) {
923 if (value[temp_len+1] ==
925 /* skip second comma */
928 /* single comma indicating start
935 if (value[temp_len] == 0) {
939 /* point option to start of next parm */
940 options = value + temp_len + 1;
942 /* go from value to value + temp_len condensing
943 double commas to singles. Note that this ends up
944 allocating a few bytes too many, which is ok */
945 vol->password = kzalloc(temp_len, GFP_KERNEL);
946 if (vol->password == NULL) {
947 printk(KERN_WARNING "CIFS: no memory "
951 for (i = 0, j = 0; i < temp_len; i++, j++) {
952 vol->password[j] = value[i];
953 if (value[i] == separator[0]
954 && value[i+1] == separator[0]) {
955 /* skip second comma */
959 vol->password[j] = 0;
961 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
962 if (vol->password == NULL) {
963 printk(KERN_WARNING "CIFS: no memory "
967 strcpy(vol->password, value);
969 } else if (strnicmp(data, "ip", 2) == 0) {
970 if (!value || !*value) {
972 } else if (strnlen(value, 35) < 35) {
975 printk(KERN_WARNING "CIFS: ip address "
979 } else if (strnicmp(data, "sec", 3) == 0) {
980 if (!value || !*value) {
981 cERROR(1, ("no security value specified"));
983 } else if (strnicmp(value, "krb5i", 5) == 0) {
984 vol->secFlg |= CIFSSEC_MAY_KRB5 |
986 } else if (strnicmp(value, "krb5p", 5) == 0) {
987 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
989 cERROR(1, ("Krb5 cifs privacy not supported"));
991 } else if (strnicmp(value, "krb5", 4) == 0) {
992 vol->secFlg |= CIFSSEC_MAY_KRB5;
993 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
994 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
996 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
997 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
998 } else if (strnicmp(value, "ntlmi", 5) == 0) {
999 vol->secFlg |= CIFSSEC_MAY_NTLM |
1001 } else if (strnicmp(value, "ntlm", 4) == 0) {
1002 /* ntlm is default so can be turned off too */
1003 vol->secFlg |= CIFSSEC_MAY_NTLM;
1004 } else if (strnicmp(value, "nontlm", 6) == 0) {
1005 /* BB is there a better way to do this? */
1006 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1007 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1008 } else if (strnicmp(value, "lanman", 6) == 0) {
1009 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1011 } else if (strnicmp(value, "none", 4) == 0) {
1014 cERROR(1, ("bad security option: %s", value));
1017 } else if ((strnicmp(data, "unc", 3) == 0)
1018 || (strnicmp(data, "target", 6) == 0)
1019 || (strnicmp(data, "path", 4) == 0)) {
1020 if (!value || !*value) {
1021 printk(KERN_WARNING "CIFS: invalid path to "
1022 "network resource\n");
1023 return 1; /* needs_arg; */
1025 if ((temp_len = strnlen(value, 300)) < 300) {
1026 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1027 if (vol->UNC == NULL)
1029 strcpy(vol->UNC, value);
1030 if (strncmp(vol->UNC, "//", 2) == 0) {
1033 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1035 "CIFS: UNC Path does not begin "
1036 "with // or \\\\ \n");
1040 printk(KERN_WARNING "CIFS: UNC name too long\n");
1043 } else if ((strnicmp(data, "domain", 3) == 0)
1044 || (strnicmp(data, "workgroup", 5) == 0)) {
1045 if (!value || !*value) {
1046 printk(KERN_WARNING "CIFS: invalid domain name\n");
1047 return 1; /* needs_arg; */
1049 /* BB are there cases in which a comma can be valid in
1050 a domain name and need special handling? */
1051 if (strnlen(value, 256) < 256) {
1052 vol->domainname = value;
1053 cFYI(1, ("Domain name set"));
1055 printk(KERN_WARNING "CIFS: domain name too "
1059 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1060 if (!value || !*value) {
1062 "CIFS: invalid path prefix\n");
1063 return 1; /* needs_argument */
1065 if ((temp_len = strnlen(value, 1024)) < 1024) {
1066 if (value[0] != '/')
1067 temp_len++; /* missing leading slash */
1068 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1069 if (vol->prepath == NULL)
1071 if (value[0] != '/') {
1072 vol->prepath[0] = '/';
1073 strcpy(vol->prepath+1, value);
1075 strcpy(vol->prepath, value);
1076 cFYI(1, ("prefix path %s", vol->prepath));
1078 printk(KERN_WARNING "CIFS: prefix too long\n");
1081 } else if (strnicmp(data, "iocharset", 9) == 0) {
1082 if (!value || !*value) {
1083 printk(KERN_WARNING "CIFS: invalid iocharset "
1085 return 1; /* needs_arg; */
1087 if (strnlen(value, 65) < 65) {
1088 if (strnicmp(value, "default", 7))
1089 vol->iocharset = value;
1090 /* if iocharset not set then load_nls_default
1091 is used by caller */
1092 cFYI(1, ("iocharset set to %s", value));
1094 printk(KERN_WARNING "CIFS: iocharset name "
1098 } else if (strnicmp(data, "uid", 3) == 0) {
1099 if (value && *value) {
1101 simple_strtoul(value, &value, 0);
1102 vol->override_uid = 1;
1104 } else if (strnicmp(data, "gid", 3) == 0) {
1105 if (value && *value) {
1107 simple_strtoul(value, &value, 0);
1108 vol->override_gid = 1;
1110 } else if (strnicmp(data, "file_mode", 4) == 0) {
1111 if (value && *value) {
1113 simple_strtoul(value, &value, 0);
1115 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1116 if (value && *value) {
1118 simple_strtoul(value, &value, 0);
1120 } else if (strnicmp(data, "dirmode", 4) == 0) {
1121 if (value && *value) {
1123 simple_strtoul(value, &value, 0);
1125 } else if (strnicmp(data, "port", 4) == 0) {
1126 if (value && *value) {
1128 simple_strtoul(value, &value, 0);
1130 } else if (strnicmp(data, "rsize", 5) == 0) {
1131 if (value && *value) {
1133 simple_strtoul(value, &value, 0);
1135 } else if (strnicmp(data, "wsize", 5) == 0) {
1136 if (value && *value) {
1138 simple_strtoul(value, &value, 0);
1140 } else if (strnicmp(data, "sockopt", 5) == 0) {
1141 if (value && *value) {
1143 simple_strtoul(value, &value, 0);
1145 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1146 if (!value || !*value || (*value == ' ')) {
1147 cFYI(1, ("invalid (empty) netbiosname"));
1149 memset(vol->source_rfc1001_name, 0x20, 15);
1150 for (i = 0; i < 15; i++) {
1151 /* BB are there cases in which a comma can be
1152 valid in this workstation netbios name (and need
1153 special handling)? */
1155 /* We do not uppercase netbiosname for user */
1159 vol->source_rfc1001_name[i] =
1162 /* The string has 16th byte zero still from
1163 set at top of the function */
1164 if ((i == 15) && (value[i] != 0))
1165 printk(KERN_WARNING "CIFS: netbiosname"
1166 " longer than 15 truncated.\n");
1168 } else if (strnicmp(data, "servern", 7) == 0) {
1169 /* servernetbiosname specified override *SMBSERVER */
1170 if (!value || !*value || (*value == ' ')) {
1171 cFYI(1, ("empty server netbiosname specified"));
1173 /* last byte, type, is 0x20 for servr type */
1174 memset(vol->target_rfc1001_name, 0x20, 16);
1176 for (i = 0; i < 15; i++) {
1177 /* BB are there cases in which a comma can be
1178 valid in this workstation netbios name
1179 (and need special handling)? */
1181 /* user or mount helper must uppercase
1186 vol->target_rfc1001_name[i] =
1189 /* The string has 16th byte zero still from
1190 set at top of the function */
1191 if ((i == 15) && (value[i] != 0))
1192 printk(KERN_WARNING "CIFS: server net"
1193 "biosname longer than 15 truncated.\n");
1195 } else if (strnicmp(data, "credentials", 4) == 0) {
1197 } else if (strnicmp(data, "version", 3) == 0) {
1199 } else if (strnicmp(data, "guest", 5) == 0) {
1201 } else if (strnicmp(data, "rw", 2) == 0) {
1203 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1204 vol->noblocksnd = 1;
1205 } else if (strnicmp(data, "noautotune", 10) == 0) {
1206 vol->noautotune = 1;
1207 } else if ((strnicmp(data, "suid", 4) == 0) ||
1208 (strnicmp(data, "nosuid", 6) == 0) ||
1209 (strnicmp(data, "exec", 4) == 0) ||
1210 (strnicmp(data, "noexec", 6) == 0) ||
1211 (strnicmp(data, "nodev", 5) == 0) ||
1212 (strnicmp(data, "noauto", 6) == 0) ||
1213 (strnicmp(data, "dev", 3) == 0)) {
1214 /* The mount tool or mount.cifs helper (if present)
1215 uses these opts to set flags, and the flags are read
1216 by the kernel vfs layer before we get here (ie
1217 before read super) so there is no point trying to
1218 parse these options again and set anything and it
1219 is ok to just ignore them */
1221 } else if (strnicmp(data, "ro", 2) == 0) {
1223 } else if (strnicmp(data, "hard", 4) == 0) {
1225 } else if (strnicmp(data, "soft", 4) == 0) {
1227 } else if (strnicmp(data, "perm", 4) == 0) {
1229 } else if (strnicmp(data, "noperm", 6) == 0) {
1231 } else if (strnicmp(data, "mapchars", 8) == 0) {
1233 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1235 } else if (strnicmp(data, "sfu", 3) == 0) {
1237 } else if (strnicmp(data, "nosfu", 5) == 0) {
1239 } else if (strnicmp(data, "nodfs", 5) == 0) {
1241 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1242 vol->posix_paths = 1;
1243 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1244 vol->posix_paths = 0;
1245 } else if (strnicmp(data, "nounix", 6) == 0) {
1246 vol->no_linux_ext = 1;
1247 } else if (strnicmp(data, "nolinux", 7) == 0) {
1248 vol->no_linux_ext = 1;
1249 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1250 (strnicmp(data, "ignorecase", 10) == 0)) {
1252 } else if (strnicmp(data, "brl", 3) == 0) {
1254 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1255 (strnicmp(data, "nolock", 6) == 0)) {
1257 /* turn off mandatory locking in mode
1258 if remote locking is turned off since the
1259 local vfs will do advisory */
1260 if (vol->file_mode ==
1261 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1262 vol->file_mode = S_IALLUGO;
1263 } else if (strnicmp(data, "setuids", 7) == 0) {
1265 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1267 } else if (strnicmp(data, "dynperm", 7) == 0) {
1268 vol->dynperm = true;
1269 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1270 vol->dynperm = false;
1271 } else if (strnicmp(data, "nohard", 6) == 0) {
1273 } else if (strnicmp(data, "nosoft", 6) == 0) {
1275 } else if (strnicmp(data, "nointr", 6) == 0) {
1277 } else if (strnicmp(data, "intr", 4) == 0) {
1279 } else if (strnicmp(data, "serverino", 7) == 0) {
1280 vol->server_ino = 1;
1281 } else if (strnicmp(data, "noserverino", 9) == 0) {
1282 vol->server_ino = 0;
1283 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1285 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1287 } else if (strnicmp(data, "acl", 3) == 0) {
1288 vol->no_psx_acl = 0;
1289 } else if (strnicmp(data, "noacl", 5) == 0) {
1290 vol->no_psx_acl = 1;
1291 #ifdef CONFIG_CIFS_EXPERIMENTAL
1292 } else if (strnicmp(data, "locallease", 6) == 0) {
1293 vol->local_lease = 1;
1295 } else if (strnicmp(data, "sign", 4) == 0) {
1296 vol->secFlg |= CIFSSEC_MUST_SIGN;
1297 } else if (strnicmp(data, "seal", 4) == 0) {
1298 /* we do not do the following in secFlags because seal
1299 is a per tree connection (mount) not a per socket
1300 or per-smb connection option in the protocol */
1301 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1303 } else if (strnicmp(data, "direct", 6) == 0) {
1305 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1307 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1308 if (!value || !*value) {
1309 vol->in6_addr = NULL;
1310 } else if (strnlen(value, 49) == 48) {
1311 vol->in6_addr = value;
1313 printk(KERN_WARNING "CIFS: ip v6 address not "
1314 "48 characters long\n");
1317 } else if (strnicmp(data, "noac", 4) == 0) {
1318 printk(KERN_WARNING "CIFS: Mount option noac not "
1319 "supported. Instead set "
1320 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1322 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1325 if (vol->UNC == NULL) {
1326 if (devname == NULL) {
1327 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1331 if ((temp_len = strnlen(devname, 300)) < 300) {
1332 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1333 if (vol->UNC == NULL)
1335 strcpy(vol->UNC, devname);
1336 if (strncmp(vol->UNC, "//", 2) == 0) {
1339 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1340 printk(KERN_WARNING "CIFS: UNC Path does not "
1341 "begin with // or \\\\ \n");
1344 value = strpbrk(vol->UNC+2, "/\\");
1348 printk(KERN_WARNING "CIFS: UNC name too long\n");
1352 if (vol->UNCip == NULL)
1353 vol->UNCip = &vol->UNC[2];
1358 static struct TCP_Server_Info *
1359 cifs_find_tcp_session(struct sockaddr *addr)
1361 struct list_head *tmp;
1362 struct TCP_Server_Info *server;
1363 struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1364 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
1366 write_lock(&cifs_tcp_ses_lock);
1367 list_for_each(tmp, &cifs_tcp_ses_list) {
1368 server = list_entry(tmp, struct TCP_Server_Info,
1371 * the demux thread can exit on its own while still in CifsNew
1372 * so don't accept any sockets in that state. Since the
1373 * tcpStatus never changes back to CifsNew it's safe to check
1374 * for this without a lock.
1376 if (server->tcpStatus == CifsNew)
1379 if (addr->sa_family == AF_INET &&
1380 (addr4->sin_addr.s_addr !=
1381 server->addr.sockAddr.sin_addr.s_addr))
1383 else if (addr->sa_family == AF_INET6 &&
1384 memcmp(&server->addr.sockAddr6.sin6_addr,
1385 &addr6->sin6_addr, sizeof(addr6->sin6_addr)))
1388 ++server->srv_count;
1389 write_unlock(&cifs_tcp_ses_lock);
1390 cFYI(1, ("Existing tcp session with server found"));
1393 write_unlock(&cifs_tcp_ses_lock);
1398 cifs_put_tcp_session(struct TCP_Server_Info *server)
1400 struct task_struct *task;
1402 write_lock(&cifs_tcp_ses_lock);
1403 if (--server->srv_count > 0) {
1404 write_unlock(&cifs_tcp_ses_lock);
1408 list_del_init(&server->tcp_ses_list);
1409 write_unlock(&cifs_tcp_ses_lock);
1411 spin_lock(&GlobalMid_Lock);
1412 server->tcpStatus = CifsExiting;
1413 spin_unlock(&GlobalMid_Lock);
1415 task = xchg(&server->tsk, NULL);
1417 force_sig(SIGKILL, task);
1420 static struct cifsSesInfo *
1421 cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
1423 struct list_head *tmp;
1424 struct cifsSesInfo *ses;
1426 write_lock(&cifs_tcp_ses_lock);
1427 list_for_each(tmp, &server->smb_ses_list) {
1428 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1429 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
1433 write_unlock(&cifs_tcp_ses_lock);
1436 write_unlock(&cifs_tcp_ses_lock);
1441 cifs_put_smb_ses(struct cifsSesInfo *ses)
1444 struct TCP_Server_Info *server = ses->server;
1446 write_lock(&cifs_tcp_ses_lock);
1447 if (--ses->ses_count > 0) {
1448 write_unlock(&cifs_tcp_ses_lock);
1452 list_del_init(&ses->smb_ses_list);
1453 write_unlock(&cifs_tcp_ses_lock);
1455 if (ses->status == CifsGood) {
1457 CIFSSMBLogoff(xid, ses);
1461 cifs_put_tcp_session(server);
1464 static struct cifsTconInfo *
1465 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1467 struct list_head *tmp;
1468 struct cifsTconInfo *tcon;
1470 write_lock(&cifs_tcp_ses_lock);
1471 list_for_each(tmp, &ses->tcon_list) {
1472 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1473 if (tcon->tidStatus == CifsExiting)
1475 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1479 write_unlock(&cifs_tcp_ses_lock);
1482 write_unlock(&cifs_tcp_ses_lock);
1487 cifs_put_tcon(struct cifsTconInfo *tcon)
1490 struct cifsSesInfo *ses = tcon->ses;
1492 write_lock(&cifs_tcp_ses_lock);
1493 if (--tcon->tc_count > 0) {
1494 write_unlock(&cifs_tcp_ses_lock);
1498 list_del_init(&tcon->tcon_list);
1499 write_unlock(&cifs_tcp_ses_lock);
1502 CIFSSMBTDis(xid, tcon);
1505 DeleteTconOplockQEntries(tcon);
1507 cifs_put_smb_ses(ses);
1511 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1512 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1513 struct dfs_info3_param **preferrals, int remap)
1518 *pnum_referrals = 0;
1521 if (pSesInfo->ipc_tid == 0) {
1522 temp_unc = kmalloc(2 /* for slashes */ +
1523 strnlen(pSesInfo->serverName,
1524 SERVER_NAME_LEN_WITH_NULL * 2)
1525 + 1 + 4 /* slash IPC$ */ + 2,
1527 if (temp_unc == NULL)
1531 strcpy(temp_unc + 2, pSesInfo->serverName);
1532 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1533 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1535 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1539 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1540 pnum_referrals, nls_codepage, remap);
1541 /* BB map targetUNCs to dfs_info3 structures, here or
1542 in CIFSGetDFSRefer BB */
1547 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1548 static struct lock_class_key cifs_key[2];
1549 static struct lock_class_key cifs_slock_key[2];
1552 cifs_reclassify_socket4(struct socket *sock)
1554 struct sock *sk = sock->sk;
1555 BUG_ON(sock_owned_by_user(sk));
1556 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1557 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1561 cifs_reclassify_socket6(struct socket *sock)
1563 struct sock *sk = sock->sk;
1564 BUG_ON(sock_owned_by_user(sk));
1565 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1566 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1570 cifs_reclassify_socket4(struct socket *sock)
1575 cifs_reclassify_socket6(struct socket *sock)
1580 /* See RFC1001 section 14 on representation of Netbios names */
1581 static void rfc1002mangle(char *target, char *source, unsigned int length)
1585 for (i = 0, j = 0; i < (length); i++) {
1586 /* mask a nibble at a time and encode */
1587 target[j] = 'A' + (0x0F & (source[i] >> 4));
1588 target[j+1] = 'A' + (0x0F & source[i]);
1596 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1597 char *netbios_name, char *target_name,
1598 bool noblocksnd, bool noautotune)
1602 __be16 orig_port = 0;
1604 if (*csocket == NULL) {
1605 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1606 IPPROTO_TCP, csocket);
1608 cERROR(1, ("Error %d creating socket", rc));
1612 /* BB other socket options to set KEEPALIVE, NODELAY? */
1613 cFYI(1, ("Socket created"));
1614 (*csocket)->sk->sk_allocation = GFP_NOFS;
1615 cifs_reclassify_socket4(*csocket);
1619 psin_server->sin_family = AF_INET;
1620 if (psin_server->sin_port) { /* user overrode default port */
1621 rc = (*csocket)->ops->connect(*csocket,
1622 (struct sockaddr *) psin_server,
1623 sizeof(struct sockaddr_in), 0);
1629 /* save original port so we can retry user specified port
1630 later if fall back ports fail this time */
1631 orig_port = psin_server->sin_port;
1633 /* do not retry on the same port we just failed on */
1634 if (psin_server->sin_port != htons(CIFS_PORT)) {
1635 psin_server->sin_port = htons(CIFS_PORT);
1637 rc = (*csocket)->ops->connect(*csocket,
1638 (struct sockaddr *) psin_server,
1639 sizeof(struct sockaddr_in), 0);
1645 psin_server->sin_port = htons(RFC1001_PORT);
1646 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1648 sizeof(struct sockaddr_in), 0);
1653 /* give up here - unless we want to retry on different
1654 protocol families some day */
1657 psin_server->sin_port = orig_port;
1658 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1659 sock_release(*csocket);
1663 /* Eventually check for other socket options to change from
1664 the default. sock_setsockopt not used because it expects
1665 user space buffer */
1666 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1667 (*csocket)->sk->sk_sndbuf,
1668 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1669 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1671 (*csocket)->sk->sk_sndtimeo = 3 * HZ;
1673 /* make the bufsizes depend on wsize/rsize and max requests */
1675 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1676 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1677 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1678 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1681 /* send RFC1001 sessinit */
1682 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1683 /* some servers require RFC1001 sessinit before sending
1684 negprot - BB check reconnection in case where second
1685 sessinit is sent but no second negprot */
1686 struct rfc1002_session_packet *ses_init_buf;
1687 struct smb_hdr *smb_buf;
1688 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1691 ses_init_buf->trailer.session_req.called_len = 32;
1692 if (target_name && (target_name[0] != 0)) {
1693 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1696 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1697 DEFAULT_CIFS_CALLED_NAME, 16);
1700 ses_init_buf->trailer.session_req.calling_len = 32;
1701 /* calling name ends in null (byte 16) from old smb
1703 if (netbios_name && (netbios_name[0] != 0)) {
1704 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1707 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1708 "LINUX_CIFS_CLNT", 16);
1710 ses_init_buf->trailer.session_req.scope1 = 0;
1711 ses_init_buf->trailer.session_req.scope2 = 0;
1712 smb_buf = (struct smb_hdr *)ses_init_buf;
1713 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1714 smb_buf->smb_buf_length = 0x81000044;
1715 rc = smb_send(*csocket, smb_buf, 0x44,
1716 (struct sockaddr *)psin_server, noblocksnd);
1717 kfree(ses_init_buf);
1718 msleep(1); /* RFC1001 layer in at least one server
1719 requires very short break before negprot
1720 presumably because not expecting negprot
1721 to follow so fast. This is a simple
1722 solution that works without
1723 complicating the code and causes no
1724 significant slowing down on mount
1725 for everyone else */
1727 /* else the negprot may still work without this
1728 even though malloc failed */
1736 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket,
1741 __be16 orig_port = 0;
1743 if (*csocket == NULL) {
1744 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1745 IPPROTO_TCP, csocket);
1747 cERROR(1, ("Error %d creating ipv6 socket", rc));
1751 /* BB other socket options to set KEEPALIVE, NODELAY? */
1752 cFYI(1, ("ipv6 Socket created"));
1753 (*csocket)->sk->sk_allocation = GFP_NOFS;
1754 cifs_reclassify_socket6(*csocket);
1758 psin_server->sin6_family = AF_INET6;
1760 if (psin_server->sin6_port) { /* user overrode default port */
1761 rc = (*csocket)->ops->connect(*csocket,
1762 (struct sockaddr *) psin_server,
1763 sizeof(struct sockaddr_in6), 0);
1769 /* save original port so we can retry user specified port
1770 later if fall back ports fail this time */
1772 orig_port = psin_server->sin6_port;
1773 /* do not retry on the same port we just failed on */
1774 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1775 psin_server->sin6_port = htons(CIFS_PORT);
1777 rc = (*csocket)->ops->connect(*csocket,
1778 (struct sockaddr *) psin_server,
1779 sizeof(struct sockaddr_in6), 0);
1785 psin_server->sin6_port = htons(RFC1001_PORT);
1786 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1787 psin_server, sizeof(struct sockaddr_in6), 0);
1792 /* give up here - unless we want to retry on different
1793 protocol families some day */
1796 psin_server->sin6_port = orig_port;
1797 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1798 sock_release(*csocket);
1802 /* Eventually check for other socket options to change from
1803 the default. sock_setsockopt not used because it expects
1804 user space buffer */
1805 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1807 (*csocket)->sk->sk_sndtimeo = 3 * HZ;
1813 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1814 struct super_block *sb, struct smb_vol *vol_info)
1816 /* if we are reconnecting then should we check to see if
1817 * any requested capabilities changed locally e.g. via
1818 * remount but we can not do much about it here
1819 * if they have (even if we could detect it by the following)
1820 * Perhaps we could add a backpointer to array of sb from tcon
1821 * or if we change to make all sb to same share the same
1822 * sb as NFS - then we only have one backpointer to sb.
1823 * What if we wanted to mount the server share twice once with
1824 * and once without posixacls or posix paths? */
1825 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1827 if (vol_info && vol_info->no_linux_ext) {
1828 tcon->fsUnixInfo.Capability = 0;
1829 tcon->unix_ext = 0; /* Unix Extensions disabled */
1830 cFYI(1, ("Linux protocol extensions disabled"));
1832 } else if (vol_info)
1833 tcon->unix_ext = 1; /* Unix Extensions supported */
1835 if (tcon->unix_ext == 0) {
1836 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1840 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1841 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1843 /* check for reconnect case in which we do not
1844 want to change the mount behavior if we can avoid it */
1845 if (vol_info == NULL) {
1846 /* turn off POSIX ACL and PATHNAMES if not set
1847 originally at mount time */
1848 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1849 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1850 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1851 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1852 cERROR(1, ("POSIXPATH support change"));
1853 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1854 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1855 cERROR(1, ("possible reconnect error"));
1857 ("server disabled POSIX path support"));
1861 cap &= CIFS_UNIX_CAP_MASK;
1862 if (vol_info && vol_info->no_psx_acl)
1863 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1864 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1865 cFYI(1, ("negotiated posix acl support"));
1867 sb->s_flags |= MS_POSIXACL;
1870 if (vol_info && vol_info->posix_paths == 0)
1871 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1872 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1873 cFYI(1, ("negotiate posix pathnames"));
1875 CIFS_SB(sb)->mnt_cifs_flags |=
1876 CIFS_MOUNT_POSIX_PATHS;
1879 /* We might be setting the path sep back to a different
1880 form if we are reconnecting and the server switched its
1881 posix path capability for this share */
1882 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1883 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1885 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1886 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1887 CIFS_SB(sb)->rsize = 127 * 1024;
1889 ("larger reads not supported by srv"));
1894 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1895 #ifdef CONFIG_CIFS_DEBUG2
1896 if (cap & CIFS_UNIX_FCNTL_CAP)
1897 cFYI(1, ("FCNTL cap"));
1898 if (cap & CIFS_UNIX_EXTATTR_CAP)
1899 cFYI(1, ("EXTATTR cap"));
1900 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1901 cFYI(1, ("POSIX path cap"));
1902 if (cap & CIFS_UNIX_XATTR_CAP)
1903 cFYI(1, ("XATTR cap"));
1904 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1905 cFYI(1, ("POSIX ACL cap"));
1906 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1907 cFYI(1, ("very large read cap"));
1908 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1909 cFYI(1, ("very large write cap"));
1910 #endif /* CIFS_DEBUG2 */
1911 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1912 if (vol_info == NULL) {
1913 cFYI(1, ("resetting capabilities failed"));
1915 cERROR(1, ("Negotiating Unix capabilities "
1916 "with the server failed. Consider "
1917 "mounting with the Unix Extensions\n"
1918 "disabled, if problems are found, "
1919 "by specifying the nounix mount "
1927 convert_delimiter(char *path, char delim)
1940 for (i = 0; path[i] != '\0'; i++) {
1941 if (path[i] == old_delim)
1946 static void setup_cifs_sb(struct smb_vol *pvolume_info,
1947 struct cifs_sb_info *cifs_sb)
1949 if (pvolume_info->rsize > CIFSMaxBufSize) {
1950 cERROR(1, ("rsize %d too large, using MaxBufSize",
1951 pvolume_info->rsize));
1952 cifs_sb->rsize = CIFSMaxBufSize;
1953 } else if ((pvolume_info->rsize) &&
1954 (pvolume_info->rsize <= CIFSMaxBufSize))
1955 cifs_sb->rsize = pvolume_info->rsize;
1957 cifs_sb->rsize = CIFSMaxBufSize;
1959 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
1960 cERROR(1, ("wsize %d too large, using 4096 instead",
1961 pvolume_info->wsize));
1962 cifs_sb->wsize = 4096;
1963 } else if (pvolume_info->wsize)
1964 cifs_sb->wsize = pvolume_info->wsize;
1966 cifs_sb->wsize = min_t(const int,
1967 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
1969 /* old default of CIFSMaxBufSize was too small now
1970 that SMB Write2 can send multiple pages in kvec.
1971 RFC1001 does not describe what happens when frame
1972 bigger than 128K is sent so use that as max in
1973 conjunction with 52K kvec constraint on arch with 4K
1976 if (cifs_sb->rsize < 2048) {
1977 cifs_sb->rsize = 2048;
1978 /* Windows ME may prefer this */
1979 cFYI(1, ("readsize set to minimum: 2048"));
1981 /* calculate prepath */
1982 cifs_sb->prepath = pvolume_info->prepath;
1983 if (cifs_sb->prepath) {
1984 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
1985 /* we can not convert the / to \ in the path
1986 separators in the prefixpath yet because we do not
1987 know (until reset_cifs_unix_caps is called later)
1988 whether POSIX PATH CAP is available. We normalize
1989 the / to \ after reset_cifs_unix_caps is called */
1990 pvolume_info->prepath = NULL;
1992 cifs_sb->prepathlen = 0;
1993 cifs_sb->mnt_uid = pvolume_info->linux_uid;
1994 cifs_sb->mnt_gid = pvolume_info->linux_gid;
1995 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
1996 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
1997 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
1998 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2000 if (pvolume_info->noperm)
2001 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2002 if (pvolume_info->setuids)
2003 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2004 if (pvolume_info->server_ino)
2005 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2006 if (pvolume_info->remap)
2007 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2008 if (pvolume_info->no_xattr)
2009 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2010 if (pvolume_info->sfu_emul)
2011 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2012 if (pvolume_info->nobrl)
2013 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2014 if (pvolume_info->cifs_acl)
2015 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2016 if (pvolume_info->override_uid)
2017 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2018 if (pvolume_info->override_gid)
2019 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2020 if (pvolume_info->dynperm)
2021 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2022 if (pvolume_info->direct_io) {
2023 cFYI(1, ("mounting share using direct i/o"));
2024 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2027 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2028 cERROR(1, ("mount option dynperm ignored if cifsacl "
2029 "mount option supported"));
2033 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2034 char *mount_data, const char *devname)
2038 struct socket *csocket = NULL;
2039 struct sockaddr addr;
2040 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2041 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2042 struct smb_vol volume_info;
2043 struct cifsSesInfo *pSesInfo = NULL;
2044 struct cifsTconInfo *tcon = NULL;
2045 struct TCP_Server_Info *srvTcp = NULL;
2049 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
2051 memset(&addr, 0, sizeof(struct sockaddr));
2052 memset(&volume_info, 0, sizeof(struct smb_vol));
2053 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
2058 if (volume_info.nullauth) {
2059 cFYI(1, ("null user"));
2060 volume_info.username = "";
2061 } else if (volume_info.username) {
2062 /* BB fixme parse for domain name here */
2063 cFYI(1, ("Username: %s", volume_info.username));
2065 cifserror("No username specified");
2066 /* In userspace mount helper we can get user name from alternate
2067 locations such as env variables and files on disk */
2072 if (volume_info.UNCip && volume_info.UNC) {
2073 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
2074 &sin_server->sin_addr.s_addr);
2077 /* not ipv4 address, try ipv6 */
2078 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
2079 &sin_server6->sin6_addr.in6_u);
2081 addr.sa_family = AF_INET6;
2083 addr.sa_family = AF_INET;
2087 /* we failed translating address */
2092 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
2095 } else if (volume_info.UNCip) {
2096 /* BB using ip addr as server name to connect to the
2098 cERROR(1, ("Connecting to DFS root not implemented yet"));
2101 } else /* which servers DFS root would we conect to */ {
2103 ("CIFS mount error: No UNC path (e.g. -o "
2104 "unc=//192.168.1.100/public) specified"));
2109 /* this is needed for ASCII cp to Unicode converts */
2110 if (volume_info.iocharset == NULL) {
2111 cifs_sb->local_nls = load_nls_default();
2112 /* load_nls_default can not return null */
2114 cifs_sb->local_nls = load_nls(volume_info.iocharset);
2115 if (cifs_sb->local_nls == NULL) {
2116 cERROR(1, ("CIFS mount error: iocharset %s not found",
2117 volume_info.iocharset));
2123 srvTcp = cifs_find_tcp_session(&addr);
2124 if (!srvTcp) { /* create socket */
2125 if (addr.sa_family == AF_INET6) {
2126 cFYI(1, ("attempting ipv6 connect"));
2127 /* BB should we allow ipv6 on port 139? */
2128 /* other OS never observed in Wild doing 139 with v6 */
2129 sin_server6->sin6_port = htons(volume_info.port);
2130 rc = ipv6_connect(sin_server6, &csocket,
2131 volume_info.noblocksnd);
2133 sin_server->sin_port = htons(volume_info.port);
2134 rc = ipv4_connect(sin_server, &csocket,
2135 volume_info.source_rfc1001_name,
2136 volume_info.target_rfc1001_name,
2137 volume_info.noblocksnd,
2138 volume_info.noautotune);
2141 cERROR(1, ("Error connecting to socket. "
2142 "Aborting operation"));
2143 if (csocket != NULL)
2144 sock_release(csocket);
2148 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2151 sock_release(csocket);
2154 srvTcp->noblocksnd = volume_info.noblocksnd;
2155 srvTcp->noautotune = volume_info.noautotune;
2156 if (addr.sa_family == AF_INET6)
2157 memcpy(&srvTcp->addr.sockAddr6, sin_server6,
2158 sizeof(struct sockaddr_in6));
2160 memcpy(&srvTcp->addr.sockAddr, sin_server,
2161 sizeof(struct sockaddr_in));
2162 atomic_set(&srvTcp->inFlight, 0);
2163 /* BB Add code for ipv6 case too */
2164 srvTcp->ssocket = csocket;
2165 srvTcp->hostname = extract_hostname(volume_info.UNC);
2166 if (IS_ERR(srvTcp->hostname)) {
2167 rc = PTR_ERR(srvTcp->hostname);
2168 sock_release(csocket);
2171 init_waitqueue_head(&srvTcp->response_q);
2172 init_waitqueue_head(&srvTcp->request_q);
2173 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
2174 /* at this point we are the only ones with the pointer
2175 to the struct since the kernel thread not created yet
2176 so no need to spinlock this init of tcpStatus */
2177 srvTcp->tcpStatus = CifsNew;
2178 init_MUTEX(&srvTcp->tcpSem);
2179 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
2180 if (IS_ERR(srvTcp->tsk)) {
2181 rc = PTR_ERR(srvTcp->tsk);
2182 cERROR(1, ("error %d create cifsd thread", rc));
2184 sock_release(csocket);
2185 kfree(srvTcp->hostname);
2189 memcpy(srvTcp->workstation_RFC1001_name,
2190 volume_info.source_rfc1001_name, 16);
2191 memcpy(srvTcp->server_RFC1001_name,
2192 volume_info.target_rfc1001_name, 16);
2193 srvTcp->sequence_number = 0;
2194 INIT_LIST_HEAD(&srvTcp->tcp_ses_list);
2195 INIT_LIST_HEAD(&srvTcp->smb_ses_list);
2196 ++srvTcp->srv_count;
2197 write_lock(&cifs_tcp_ses_lock);
2198 list_add(&srvTcp->tcp_ses_list,
2199 &cifs_tcp_ses_list);
2200 write_unlock(&cifs_tcp_ses_lock);
2204 pSesInfo = cifs_find_smb_ses(srvTcp, volume_info.username);
2206 cFYI(1, ("Existing smb sess found (status=%d)",
2209 * The existing SMB session already has a reference to srvTcp,
2210 * so we can put back the extra one we got before
2212 cifs_put_tcp_session(srvTcp);
2214 down(&pSesInfo->sesSem);
2215 if (pSesInfo->need_reconnect) {
2216 cFYI(1, ("Session needs reconnect"));
2217 rc = cifs_setup_session(xid, pSesInfo,
2218 cifs_sb->local_nls);
2220 up(&pSesInfo->sesSem);
2222 cFYI(1, ("Existing smb sess not found"));
2223 pSesInfo = sesInfoAlloc();
2224 if (pSesInfo == NULL) {
2226 goto mount_fail_check;
2229 /* new SMB session uses our srvTcp ref */
2230 pSesInfo->server = srvTcp;
2231 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2232 NIPQUAD(sin_server->sin_addr.s_addr));
2234 write_lock(&cifs_tcp_ses_lock);
2235 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2236 write_unlock(&cifs_tcp_ses_lock);
2238 /* volume_info.password freed at unmount */
2239 if (volume_info.password) {
2240 pSesInfo->password = volume_info.password;
2241 /* set to NULL to prevent freeing on exit */
2242 volume_info.password = NULL;
2244 if (volume_info.username)
2245 strncpy(pSesInfo->userName, volume_info.username,
2247 if (volume_info.domainname) {
2248 int len = strlen(volume_info.domainname);
2249 pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2250 if (pSesInfo->domainName)
2251 strcpy(pSesInfo->domainName,
2252 volume_info.domainname);
2254 pSesInfo->linux_uid = volume_info.linux_uid;
2255 pSesInfo->overrideSecFlg = volume_info.secFlg;
2256 down(&pSesInfo->sesSem);
2258 /* BB FIXME need to pass vol->secFlgs BB */
2259 rc = cifs_setup_session(xid, pSesInfo,
2260 cifs_sb->local_nls);
2261 up(&pSesInfo->sesSem);
2264 /* search for existing tcon to this server share */
2266 setup_cifs_sb(&volume_info, cifs_sb);
2268 tcon = cifs_find_tcon(pSesInfo, volume_info.UNC);
2270 cFYI(1, ("Found match on UNC path"));
2271 /* existing tcon already has a reference */
2272 cifs_put_smb_ses(pSesInfo);
2274 tcon = tconInfoAlloc();
2277 goto mount_fail_check;
2280 /* check for null share name ie connect to dfs root */
2282 /* BB check if works for exactly length 3 strings */
2283 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2284 && (strchr(volume_info.UNC + 3, '/') == NULL)) {
2285 /* rc = connect_to_dfs_path(...) */
2286 cFYI(1, ("DFS root not supported"));
2288 goto mount_fail_check;
2290 /* BB Do we need to wrap sesSem around
2291 * this TCon call and Unix SetFS as
2292 * we do on SessSetup and reconnect? */
2293 rc = CIFSTCon(xid, pSesInfo, volume_info.UNC,
2294 tcon, cifs_sb->local_nls);
2295 cFYI(1, ("CIFS Tcon rc = %d", rc));
2296 if (volume_info.nodfs) {
2297 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2298 cFYI(1, ("DFS disabled (%d)",
2303 goto mount_fail_check;
2304 tcon->seal = volume_info.seal;
2305 tcon->ses = pSesInfo;
2306 write_lock(&cifs_tcp_ses_lock);
2307 list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2308 write_unlock(&cifs_tcp_ses_lock);
2311 /* we can have only one retry value for a connection
2312 to a share so for resources mounted more than once
2313 to the same server share the last value passed in
2314 for the retry flag is used */
2315 tcon->retry = volume_info.retry;
2316 tcon->nocase = volume_info.nocase;
2317 tcon->local_lease = volume_info.local_lease;
2320 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2321 sb->s_maxbytes = (u64) 1 << 63;
2323 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2326 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2327 sb->s_time_gran = 100;
2330 /* on error free sesinfo and tcon struct if needed */
2332 /* If find_unc succeeded then rc == 0 so we can not end */
2333 /* up accidently freeing someone elses tcon struct */
2335 cifs_put_tcon(tcon);
2337 cifs_put_smb_ses(pSesInfo);
2339 cifs_put_tcp_session(srvTcp);
2342 cifs_sb->tcon = tcon;
2344 /* do not care if following two calls succeed - informational */
2346 CIFSSMBQFSDeviceInfo(xid, tcon);
2347 CIFSSMBQFSAttributeInfo(xid, tcon);
2350 /* tell server which Unix caps we support */
2351 if (tcon->ses->capabilities & CAP_UNIX)
2352 /* reset of caps checks mount to see if unix extensions
2353 disabled for just this mount */
2354 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2356 tcon->unix_ext = 0; /* server does not support them */
2358 /* convert forward to back slashes in prepath here if needed */
2359 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2360 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2362 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2363 cifs_sb->rsize = 1024 * 127;
2364 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2366 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2367 cifs_sb->wsize = min(cifs_sb->wsize,
2368 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2369 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2370 cifs_sb->rsize = min(cifs_sb->rsize,
2371 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2373 /* volume_info.password is freed above when existing session found
2374 (in which case it is not needed anymore) but when new sesion is created
2375 the password ptr is put in the new session structure (in which case the
2376 password will be freed at unmount time) */
2378 /* zero out password before freeing */
2379 if (volume_info.password != NULL) {
2380 memset(volume_info.password, 0, strlen(volume_info.password));
2381 kfree(volume_info.password);
2383 kfree(volume_info.UNC);
2384 kfree(volume_info.prepath);
2390 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2391 char session_key[CIFS_SESS_KEY_SIZE],
2392 const struct nls_table *nls_codepage)
2394 struct smb_hdr *smb_buffer;
2395 struct smb_hdr *smb_buffer_response;
2396 SESSION_SETUP_ANDX *pSMB;
2397 SESSION_SETUP_ANDX *pSMBr;
2402 int remaining_words = 0;
2403 int bytes_returned = 0;
2408 cFYI(1, ("In sesssetup"));
2411 user = ses->userName;
2412 domain = ses->domainName;
2413 smb_buffer = cifs_buf_get();
2415 if (smb_buffer == NULL)
2418 smb_buffer_response = smb_buffer;
2419 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2421 /* send SMBsessionSetup here */
2422 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2423 NULL /* no tCon exists yet */ , 13 /* wct */ );
2425 smb_buffer->Mid = GetNextMid(ses->server);
2426 pSMB->req_no_secext.AndXCommand = 0xFF;
2427 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2428 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2430 if (ses->server->secMode &
2431 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2432 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2434 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2435 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2436 if (ses->capabilities & CAP_UNICODE) {
2437 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2438 capabilities |= CAP_UNICODE;
2440 if (ses->capabilities & CAP_STATUS32) {
2441 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2442 capabilities |= CAP_STATUS32;
2444 if (ses->capabilities & CAP_DFS) {
2445 smb_buffer->Flags2 |= SMBFLG2_DFS;
2446 capabilities |= CAP_DFS;
2448 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2450 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2451 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2453 pSMB->req_no_secext.CaseSensitivePasswordLength =
2454 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2455 bcc_ptr = pByteArea(smb_buffer);
2456 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2457 bcc_ptr += CIFS_SESS_KEY_SIZE;
2458 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2459 bcc_ptr += CIFS_SESS_KEY_SIZE;
2461 if (ses->capabilities & CAP_UNICODE) {
2462 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2467 bytes_returned = 0; /* skip null user */
2470 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2472 /* convert number of 16 bit words to bytes */
2473 bcc_ptr += 2 * bytes_returned;
2474 bcc_ptr += 2; /* trailing null */
2477 cifs_strtoUCS((__le16 *) bcc_ptr,
2478 "CIFS_LINUX_DOM", 32, nls_codepage);
2481 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2483 bcc_ptr += 2 * bytes_returned;
2486 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2488 bcc_ptr += 2 * bytes_returned;
2490 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2492 bcc_ptr += 2 * bytes_returned;
2495 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2497 bcc_ptr += 2 * bytes_returned;
2501 strncpy(bcc_ptr, user, 200);
2502 bcc_ptr += strnlen(user, 200);
2506 if (domain == NULL) {
2507 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2508 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2510 strncpy(bcc_ptr, domain, 64);
2511 bcc_ptr += strnlen(domain, 64);
2515 strcpy(bcc_ptr, "Linux version ");
2516 bcc_ptr += strlen("Linux version ");
2517 strcpy(bcc_ptr, utsname()->release);
2518 bcc_ptr += strlen(utsname()->release) + 1;
2519 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2520 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2522 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2523 smb_buffer->smb_buf_length += count;
2524 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2526 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2527 &bytes_returned, CIFS_LONG_OP);
2529 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2530 } else if ((smb_buffer_response->WordCount == 3)
2531 || (smb_buffer_response->WordCount == 4)) {
2532 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2533 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2534 if (action & GUEST_LOGIN)
2535 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2536 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2538 cFYI(1, ("UID = %d ", ses->Suid));
2539 /* response can have either 3 or 4 word count - Samba sends 3 */
2540 bcc_ptr = pByteArea(smb_buffer_response);
2541 if ((pSMBr->resp.hdr.WordCount == 3)
2542 || ((pSMBr->resp.hdr.WordCount == 4)
2543 && (blob_len < pSMBr->resp.ByteCount))) {
2544 if (pSMBr->resp.hdr.WordCount == 4)
2545 bcc_ptr += blob_len;
2547 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2548 if ((long) (bcc_ptr) % 2) {
2550 (BCC(smb_buffer_response) - 1) / 2;
2551 /* Unicode strings must be word
2556 BCC(smb_buffer_response) / 2;
2559 UniStrnlen((wchar_t *) bcc_ptr,
2560 remaining_words - 1);
2561 /* We look for obvious messed up bcc or strings in response so we do not go off
2562 the end since (at least) WIN2K and Windows XP have a major bug in not null
2563 terminating last Unicode string in response */
2565 kfree(ses->serverOS);
2566 ses->serverOS = kzalloc(2 * (len + 1),
2568 if (ses->serverOS == NULL)
2569 goto sesssetup_nomem;
2570 cifs_strfromUCS_le(ses->serverOS,
2573 bcc_ptr += 2 * (len + 1);
2574 remaining_words -= len + 1;
2575 ses->serverOS[2 * len] = 0;
2576 ses->serverOS[1 + (2 * len)] = 0;
2577 if (remaining_words > 0) {
2578 len = UniStrnlen((wchar_t *)bcc_ptr,
2580 kfree(ses->serverNOS);
2581 ses->serverNOS = kzalloc(2 * (len + 1),
2583 if (ses->serverNOS == NULL)
2584 goto sesssetup_nomem;
2585 cifs_strfromUCS_le(ses->serverNOS,
2588 bcc_ptr += 2 * (len + 1);
2589 ses->serverNOS[2 * len] = 0;
2590 ses->serverNOS[1 + (2 * len)] = 0;
2591 if (strncmp(ses->serverNOS,
2592 "NT LAN Manager 4", 16) == 0) {
2593 cFYI(1, ("NT4 server"));
2594 ses->flags |= CIFS_SES_NT4;
2596 remaining_words -= len + 1;
2597 if (remaining_words > 0) {
2598 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2599 /* last string is not always null terminated
2600 (for e.g. for Windows XP & 2000) */
2601 if (ses->serverDomain)
2602 kfree(ses->serverDomain);
2606 if (ses->serverDomain == NULL)
2607 goto sesssetup_nomem;
2608 cifs_strfromUCS_le(ses->serverDomain,
2611 bcc_ptr += 2 * (len + 1);
2612 ses->serverDomain[2*len] = 0;
2613 ses->serverDomain[1+(2*len)] = 0;
2614 } else { /* else no more room so create
2615 dummy domain string */
2616 if (ses->serverDomain)
2617 kfree(ses->serverDomain);
2619 kzalloc(2, GFP_KERNEL);
2621 } else { /* no room so create dummy domain
2624 /* if these kcallocs fail not much we
2625 can do, but better to not fail the
2627 kfree(ses->serverDomain);
2629 kzalloc(2, GFP_KERNEL);
2630 kfree(ses->serverNOS);
2632 kzalloc(2, GFP_KERNEL);
2634 } else { /* ASCII */
2635 len = strnlen(bcc_ptr, 1024);
2636 if (((long) bcc_ptr + len) - (long)
2637 pByteArea(smb_buffer_response)
2638 <= BCC(smb_buffer_response)) {
2639 kfree(ses->serverOS);
2640 ses->serverOS = kzalloc(len + 1,
2642 if (ses->serverOS == NULL)
2643 goto sesssetup_nomem;
2644 strncpy(ses->serverOS, bcc_ptr, len);
2647 /* null terminate the string */
2651 len = strnlen(bcc_ptr, 1024);
2652 kfree(ses->serverNOS);
2653 ses->serverNOS = kzalloc(len + 1,
2655 if (ses->serverNOS == NULL)
2656 goto sesssetup_nomem;
2657 strncpy(ses->serverNOS, bcc_ptr, len);
2662 len = strnlen(bcc_ptr, 1024);
2663 if (ses->serverDomain)
2664 kfree(ses->serverDomain);
2665 ses->serverDomain = kzalloc(len + 1,
2667 if (ses->serverDomain == NULL)
2668 goto sesssetup_nomem;
2669 strncpy(ses->serverDomain, bcc_ptr,
2676 ("Variable field of length %d "
2677 "extends beyond end of smb ",
2682 (" Security Blob Length extends beyond "
2687 (" Invalid Word count %d: ",
2688 smb_buffer_response->WordCount));
2691 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2692 since that could make reconnection harder, and
2693 reconnection might be needed to free memory */
2694 cifs_buf_release(smb_buffer);
2700 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2701 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2702 const struct nls_table *nls_codepage)
2704 struct smb_hdr *smb_buffer;
2705 struct smb_hdr *smb_buffer_response;
2706 SESSION_SETUP_ANDX *pSMB;
2707 SESSION_SETUP_ANDX *pSMBr;
2711 int remaining_words = 0;
2712 int bytes_returned = 0;
2714 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2715 PNEGOTIATE_MESSAGE SecurityBlob;
2716 PCHALLENGE_MESSAGE SecurityBlob2;
2717 __u32 negotiate_flags, capabilities;
2720 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2723 domain = ses->domainName;
2724 *pNTLMv2_flag = false;
2725 smb_buffer = cifs_buf_get();
2726 if (smb_buffer == NULL) {
2729 smb_buffer_response = smb_buffer;
2730 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2731 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2733 /* send SMBsessionSetup here */
2734 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2735 NULL /* no tCon exists yet */ , 12 /* wct */ );
2737 smb_buffer->Mid = GetNextMid(ses->server);
2738 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2739 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2741 pSMB->req.AndXCommand = 0xFF;
2742 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2743 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2745 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2746 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2748 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2749 CAP_EXTENDED_SECURITY;
2750 if (ses->capabilities & CAP_UNICODE) {
2751 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2752 capabilities |= CAP_UNICODE;
2754 if (ses->capabilities & CAP_STATUS32) {
2755 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2756 capabilities |= CAP_STATUS32;
2758 if (ses->capabilities & CAP_DFS) {
2759 smb_buffer->Flags2 |= SMBFLG2_DFS;
2760 capabilities |= CAP_DFS;
2762 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2764 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2765 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2766 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2767 SecurityBlob->MessageType = NtLmNegotiate;
2769 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2770 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2771 NTLMSSP_NEGOTIATE_56 |
2772 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2774 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2775 /* if (ntlmv2_support)
2776 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2777 /* setup pointers to domain name and workstation name */
2778 bcc_ptr += SecurityBlobLength;
2780 SecurityBlob->WorkstationName.Buffer = 0;
2781 SecurityBlob->WorkstationName.Length = 0;
2782 SecurityBlob->WorkstationName.MaximumLength = 0;
2784 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2785 along with username on auth request (ie the response to challenge) */
2786 SecurityBlob->DomainName.Buffer = 0;
2787 SecurityBlob->DomainName.Length = 0;
2788 SecurityBlob->DomainName.MaximumLength = 0;
2789 if (ses->capabilities & CAP_UNICODE) {
2790 if ((long) bcc_ptr % 2) {
2796 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2798 bcc_ptr += 2 * bytes_returned;
2800 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2802 bcc_ptr += 2 * bytes_returned;
2803 bcc_ptr += 2; /* null terminate Linux version */
2805 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2807 bcc_ptr += 2 * bytes_returned;
2810 bcc_ptr += 2; /* null terminate network opsys string */
2813 bcc_ptr += 2; /* null domain */
2814 } else { /* ASCII */
2815 strcpy(bcc_ptr, "Linux version ");
2816 bcc_ptr += strlen("Linux version ");
2817 strcpy(bcc_ptr, utsname()->release);
2818 bcc_ptr += strlen(utsname()->release) + 1;
2819 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2820 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2821 bcc_ptr++; /* empty domain field */
2824 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2825 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2826 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2827 smb_buffer->smb_buf_length += count;
2828 pSMB->req.ByteCount = cpu_to_le16(count);
2830 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2831 &bytes_returned, CIFS_LONG_OP);
2833 if (smb_buffer_response->Status.CifsError ==
2834 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2838 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2839 } else if ((smb_buffer_response->WordCount == 3)
2840 || (smb_buffer_response->WordCount == 4)) {
2841 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2842 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2844 if (action & GUEST_LOGIN)
2845 cFYI(1, (" Guest login"));
2846 /* Do we want to set anything in SesInfo struct when guest login? */
2848 bcc_ptr = pByteArea(smb_buffer_response);
2849 /* response can have either 3 or 4 word count - Samba sends 3 */
2851 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2852 if (SecurityBlob2->MessageType != NtLmChallenge) {
2854 ("Unexpected NTLMSSP message type received %d",
2855 SecurityBlob2->MessageType));
2857 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2858 cFYI(1, ("UID = %d", ses->Suid));
2859 if ((pSMBr->resp.hdr.WordCount == 3)
2860 || ((pSMBr->resp.hdr.WordCount == 4)
2862 pSMBr->resp.ByteCount))) {
2864 if (pSMBr->resp.hdr.WordCount == 4) {
2865 bcc_ptr += blob_len;
2866 cFYI(1, ("Security Blob Length %d",
2870 cFYI(1, ("NTLMSSP Challenge rcvd"));
2872 memcpy(ses->server->cryptKey,
2873 SecurityBlob2->Challenge,
2874 CIFS_CRYPTO_KEY_SIZE);
2875 if (SecurityBlob2->NegotiateFlags &
2876 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2877 *pNTLMv2_flag = true;
2879 if ((SecurityBlob2->NegotiateFlags &
2880 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2881 || (sign_CIFS_PDUs > 1))
2882 ses->server->secMode |=
2883 SECMODE_SIGN_REQUIRED;
2884 if ((SecurityBlob2->NegotiateFlags &
2885 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2886 ses->server->secMode |=
2887 SECMODE_SIGN_ENABLED;
2889 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2890 if ((long) (bcc_ptr) % 2) {
2892 (BCC(smb_buffer_response)
2894 /* Must word align unicode strings */
2899 (smb_buffer_response) / 2;
2902 UniStrnlen((wchar_t *) bcc_ptr,
2903 remaining_words - 1);
2904 /* We look for obvious messed up bcc or strings in response so we do not go off
2905 the end since (at least) WIN2K and Windows XP have a major bug in not null
2906 terminating last Unicode string in response */
2908 kfree(ses->serverOS);
2910 kzalloc(2 * (len + 1), GFP_KERNEL);
2911 cifs_strfromUCS_le(ses->serverOS,
2915 bcc_ptr += 2 * (len + 1);
2916 remaining_words -= len + 1;
2917 ses->serverOS[2 * len] = 0;
2918 ses->serverOS[1 + (2 * len)] = 0;
2919 if (remaining_words > 0) {
2920 len = UniStrnlen((wchar_t *)
2924 kfree(ses->serverNOS);
2926 kzalloc(2 * (len + 1),
2928 cifs_strfromUCS_le(ses->
2934 bcc_ptr += 2 * (len + 1);
2935 ses->serverNOS[2 * len] = 0;
2938 remaining_words -= len + 1;
2939 if (remaining_words > 0) {
2940 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2941 /* last string not always null terminated
2942 (for e.g. for Windows XP & 2000) */
2943 kfree(ses->serverDomain);
2955 ses->serverDomain[2*len]
2960 } /* else no more room so create dummy domain string */
2962 kfree(ses->serverDomain);
2967 } else { /* no room so create dummy domain and NOS string */
2968 kfree(ses->serverDomain);
2970 kzalloc(2, GFP_KERNEL);
2971 kfree(ses->serverNOS);
2973 kzalloc(2, GFP_KERNEL);
2975 } else { /* ASCII */
2976 len = strnlen(bcc_ptr, 1024);
2977 if (((long) bcc_ptr + len) - (long)
2978 pByteArea(smb_buffer_response)
2979 <= BCC(smb_buffer_response)) {
2981 kfree(ses->serverOS);
2985 strncpy(ses->serverOS,
2989 bcc_ptr[0] = 0; /* null terminate string */
2992 len = strnlen(bcc_ptr, 1024);
2993 kfree(ses->serverNOS);
2997 strncpy(ses->serverNOS, bcc_ptr, len);
3002 len = strnlen(bcc_ptr, 1024);
3003 kfree(ses->serverDomain);
3007 strncpy(ses->serverDomain,
3014 ("field of length %d "
3015 "extends beyond end of smb",
3019 cERROR(1, ("Security Blob Length extends beyond"
3023 cERROR(1, ("No session structure passed in."));
3027 (" Invalid Word count %d:",
3028 smb_buffer_response->WordCount));
3032 cifs_buf_release(smb_buffer);
3037 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
3038 char *ntlm_session_key, bool ntlmv2_flag,
3039 const struct nls_table *nls_codepage)
3041 struct smb_hdr *smb_buffer;
3042 struct smb_hdr *smb_buffer_response;
3043 SESSION_SETUP_ANDX *pSMB;
3044 SESSION_SETUP_ANDX *pSMBr;
3049 int remaining_words = 0;
3050 int bytes_returned = 0;
3052 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
3053 PAUTHENTICATE_MESSAGE SecurityBlob;
3054 __u32 negotiate_flags, capabilities;
3057 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
3060 user = ses->userName;
3061 domain = ses->domainName;
3062 smb_buffer = cifs_buf_get();
3063 if (smb_buffer == NULL) {
3066 smb_buffer_response = smb_buffer;
3067 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
3068 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
3070 /* send SMBsessionSetup here */
3071 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
3072 NULL /* no tCon exists yet */ , 12 /* wct */ );
3074 smb_buffer->Mid = GetNextMid(ses->server);
3075 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
3076 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
3077 pSMB->req.AndXCommand = 0xFF;
3078 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
3079 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
3081 pSMB->req.hdr.Uid = ses->Suid;
3083 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3084 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3086 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
3087 CAP_EXTENDED_SECURITY;
3088 if (ses->capabilities & CAP_UNICODE) {
3089 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3090 capabilities |= CAP_UNICODE;
3092 if (ses->capabilities & CAP_STATUS32) {
3093 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3094 capabilities |= CAP_STATUS32;
3096 if (ses->capabilities & CAP_DFS) {
3097 smb_buffer->Flags2 |= SMBFLG2_DFS;
3098 capabilities |= CAP_DFS;
3100 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3102 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3103 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3104 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3105 SecurityBlob->MessageType = NtLmAuthenticate;
3106 bcc_ptr += SecurityBlobLength;
3107 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3108 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3109 0x80000000 | NTLMSSP_NEGOTIATE_128;
3111 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3113 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3115 /* setup pointers to domain name and workstation name */
3117 SecurityBlob->WorkstationName.Buffer = 0;
3118 SecurityBlob->WorkstationName.Length = 0;
3119 SecurityBlob->WorkstationName.MaximumLength = 0;
3120 SecurityBlob->SessionKey.Length = 0;
3121 SecurityBlob->SessionKey.MaximumLength = 0;
3122 SecurityBlob->SessionKey.Buffer = 0;
3124 SecurityBlob->LmChallengeResponse.Length = 0;
3125 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3126 SecurityBlob->LmChallengeResponse.Buffer = 0;
3128 SecurityBlob->NtChallengeResponse.Length =
3129 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3130 SecurityBlob->NtChallengeResponse.MaximumLength =
3131 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3132 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3133 SecurityBlob->NtChallengeResponse.Buffer =
3134 cpu_to_le32(SecurityBlobLength);
3135 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3136 bcc_ptr += CIFS_SESS_KEY_SIZE;
3138 if (ses->capabilities & CAP_UNICODE) {
3139 if (domain == NULL) {
3140 SecurityBlob->DomainName.Buffer = 0;
3141 SecurityBlob->DomainName.Length = 0;
3142 SecurityBlob->DomainName.MaximumLength = 0;
3144 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3147 SecurityBlob->DomainName.MaximumLength =
3149 SecurityBlob->DomainName.Buffer =
3150 cpu_to_le32(SecurityBlobLength);
3152 SecurityBlobLength += ln;
3153 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3156 SecurityBlob->UserName.Buffer = 0;
3157 SecurityBlob->UserName.Length = 0;
3158 SecurityBlob->UserName.MaximumLength = 0;
3160 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3163 SecurityBlob->UserName.MaximumLength =
3165 SecurityBlob->UserName.Buffer =
3166 cpu_to_le32(SecurityBlobLength);
3168 SecurityBlobLength += ln;
3169 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3172 /* SecurityBlob->WorkstationName.Length =
3173 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3174 SecurityBlob->WorkstationName.Length *= 2;
3175 SecurityBlob->WorkstationName.MaximumLength =
3176 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3177 SecurityBlob->WorkstationName.Buffer =
3178 cpu_to_le32(SecurityBlobLength);
3179 bcc_ptr += SecurityBlob->WorkstationName.Length;
3180 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3181 SecurityBlob->WorkstationName.Length =
3182 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3184 if ((long) bcc_ptr % 2) {
3189 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3191 bcc_ptr += 2 * bytes_returned;
3193 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3195 bcc_ptr += 2 * bytes_returned;
3196 bcc_ptr += 2; /* null term version string */
3198 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3200 bcc_ptr += 2 * bytes_returned;
3203 bcc_ptr += 2; /* null terminate network opsys string */
3206 bcc_ptr += 2; /* null domain */
3207 } else { /* ASCII */
3208 if (domain == NULL) {
3209 SecurityBlob->DomainName.Buffer = 0;
3210 SecurityBlob->DomainName.Length = 0;
3211 SecurityBlob->DomainName.MaximumLength = 0;
3214 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3215 strncpy(bcc_ptr, domain, 63);
3216 ln = strnlen(domain, 64);
3217 SecurityBlob->DomainName.MaximumLength =
3219 SecurityBlob->DomainName.Buffer =
3220 cpu_to_le32(SecurityBlobLength);
3222 SecurityBlobLength += ln;
3223 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3226 SecurityBlob->UserName.Buffer = 0;
3227 SecurityBlob->UserName.Length = 0;
3228 SecurityBlob->UserName.MaximumLength = 0;
3231 strncpy(bcc_ptr, user, 63);
3232 ln = strnlen(user, 64);
3233 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3234 SecurityBlob->UserName.Buffer =
3235 cpu_to_le32(SecurityBlobLength);
3237 SecurityBlobLength += ln;
3238 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3240 /* BB fill in our workstation name if known BB */
3242 strcpy(bcc_ptr, "Linux version ");
3243 bcc_ptr += strlen("Linux version ");
3244 strcpy(bcc_ptr, utsname()->release);
3245 bcc_ptr += strlen(utsname()->release) + 1;
3246 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3247 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3248 bcc_ptr++; /* null domain */
3251 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3252 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3253 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3254 smb_buffer->smb_buf_length += count;
3255 pSMB->req.ByteCount = cpu_to_le16(count);
3257 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3258 &bytes_returned, CIFS_LONG_OP);
3260 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3261 } else if ((smb_buffer_response->WordCount == 3) ||
3262 (smb_buffer_response->WordCount == 4)) {
3263 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3264 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3265 if (action & GUEST_LOGIN)
3266 cFYI(1, (" Guest login")); /* BB Should we set anything
3267 in SesInfo struct ? */
3268 /* if (SecurityBlob2->MessageType != NtLm??) {
3269 cFYI("Unexpected message type on auth response is %d"));
3274 ("Check challenge UID %d vs auth response UID %d",
3275 ses->Suid, smb_buffer_response->Uid));
3276 /* UID left in wire format */
3277 ses->Suid = smb_buffer_response->Uid;
3278 bcc_ptr = pByteArea(smb_buffer_response);
3279 /* response can have either 3 or 4 word count - Samba sends 3 */
3280 if ((pSMBr->resp.hdr.WordCount == 3)
3281 || ((pSMBr->resp.hdr.WordCount == 4)
3283 pSMBr->resp.ByteCount))) {
3284 if (pSMBr->resp.hdr.WordCount == 4) {
3288 ("Security Blob Length %d ",
3293 ("NTLMSSP response to Authenticate "));
3295 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3296 if ((long) (bcc_ptr) % 2) {
3298 (BCC(smb_buffer_response)
3300 bcc_ptr++; /* Unicode strings must be word aligned */
3302 remaining_words = BCC(smb_buffer_response) / 2;
3304 len = UniStrnlen((wchar_t *) bcc_ptr,
3305 remaining_words - 1);
3306 /* We look for obvious messed up bcc or strings in response so we do not go off
3307 the end since (at least) WIN2K and Windows XP have a major bug in not null
3308 terminating last Unicode string in response */
3310 kfree(ses->serverOS);
3312 kzalloc(2 * (len + 1), GFP_KERNEL);
3313 cifs_strfromUCS_le(ses->serverOS,
3317 bcc_ptr += 2 * (len + 1);
3318 remaining_words -= len + 1;
3319 ses->serverOS[2 * len] = 0;
3320 ses->serverOS[1 + (2 * len)] = 0;
3321 if (remaining_words > 0) {
3322 len = UniStrnlen((wchar_t *)
3326 kfree(ses->serverNOS);
3328 kzalloc(2 * (len + 1),
3330 cifs_strfromUCS_le(ses->
3336 bcc_ptr += 2 * (len + 1);
3337 ses->serverNOS[2 * len] = 0;
3338 ses->serverNOS[1+(2*len)] = 0;
3339 remaining_words -= len + 1;
3340 if (remaining_words > 0) {
3341 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3342 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3343 if (ses->serverDomain)
3344 kfree(ses->serverDomain);
3369 } /* else no more room so create dummy domain string */
3371 if (ses->serverDomain)
3372 kfree(ses->serverDomain);
3373 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3375 } else { /* no room so create dummy domain and NOS string */
3376 if (ses->serverDomain)
3377 kfree(ses->serverDomain);
3378 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3379 kfree(ses->serverNOS);
3380 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3382 } else { /* ASCII */
3383 len = strnlen(bcc_ptr, 1024);
3384 if (((long) bcc_ptr + len) -
3385 (long) pByteArea(smb_buffer_response)
3386 <= BCC(smb_buffer_response)) {
3388 kfree(ses->serverOS);
3389 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3390 strncpy(ses->serverOS,bcc_ptr, len);
3393 bcc_ptr[0] = 0; /* null terminate the string */
3396 len = strnlen(bcc_ptr, 1024);
3397 kfree(ses->serverNOS);
3398 ses->serverNOS = kzalloc(len+1,
3400 strncpy(ses->serverNOS,
3406 len = strnlen(bcc_ptr, 1024);
3407 if (ses->serverDomain)
3408 kfree(ses->serverDomain);
3412 strncpy(ses->serverDomain,
3418 cFYI(1, ("field of length %d "
3419 "extends beyond end of smb ",
3423 cERROR(1, ("Security Blob extends beyond end "
3427 cERROR(1, ("No session structure passed in."));
3430 cERROR(1, ("Invalid Word count %d: ",
3431 smb_buffer_response->WordCount));
3435 cifs_buf_release(smb_buffer);
3441 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3442 const char *tree, struct cifsTconInfo *tcon,
3443 const struct nls_table *nls_codepage)
3445 struct smb_hdr *smb_buffer;
3446 struct smb_hdr *smb_buffer_response;
3449 unsigned char *bcc_ptr;
3457 smb_buffer = cifs_buf_get();
3458 if (smb_buffer == NULL) {
3461 smb_buffer_response = smb_buffer;
3463 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3464 NULL /*no tid */ , 4 /*wct */ );
3466 smb_buffer->Mid = GetNextMid(ses->server);
3467 smb_buffer->Uid = ses->Suid;
3468 pSMB = (TCONX_REQ *) smb_buffer;
3469 pSMBr = (TCONX_RSP *) smb_buffer_response;
3471 pSMB->AndXCommand = 0xFF;
3472 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3473 bcc_ptr = &pSMB->Password[0];
3474 if ((ses->server->secMode) & SECMODE_USER) {
3475 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3476 *bcc_ptr = 0; /* password is null byte */
3477 bcc_ptr++; /* skip password */
3478 /* already aligned so no need to do it below */
3480 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3481 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3482 specified as required (when that support is added to
3483 the vfs in the future) as only NTLM or the much
3484 weaker LANMAN (which we do not send by default) is accepted
3485 by Samba (not sure whether other servers allow
3486 NTLMv2 password here) */
3487 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3488 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3489 (ses->server->secType == LANMAN))
3490 calc_lanman_hash(ses, bcc_ptr);
3492 #endif /* CIFS_WEAK_PW_HASH */
3493 SMBNTencrypt(ses->password,
3494 ses->server->cryptKey,
3497 bcc_ptr += CIFS_SESS_KEY_SIZE;
3498 if (ses->capabilities & CAP_UNICODE) {
3499 /* must align unicode strings */
3500 *bcc_ptr = 0; /* null byte password */
3505 if (ses->server->secMode &
3506 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3507 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3509 if (ses->capabilities & CAP_STATUS32) {
3510 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3512 if (ses->capabilities & CAP_DFS) {
3513 smb_buffer->Flags2 |= SMBFLG2_DFS;
3515 if (ses->capabilities & CAP_UNICODE) {
3516 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3518 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3519 6 /* max utf8 char length in bytes */ *
3520 (/* server len*/ + 256 /* share len */), nls_codepage);
3521 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3522 bcc_ptr += 2; /* skip trailing null */
3523 } else { /* ASCII */
3524 strcpy(bcc_ptr, tree);
3525 bcc_ptr += strlen(tree) + 1;
3527 strcpy(bcc_ptr, "?????");
3528 bcc_ptr += strlen("?????");
3530 count = bcc_ptr - &pSMB->Password[0];
3531 pSMB->hdr.smb_buf_length += count;
3532 pSMB->ByteCount = cpu_to_le16(count);
3534 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3537 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3538 /* above now done in SendReceive */
3539 if ((rc == 0) && (tcon != NULL)) {
3540 tcon->tidStatus = CifsGood;
3541 tcon->need_reconnect = false;
3542 tcon->tid = smb_buffer_response->Tid;
3543 bcc_ptr = pByteArea(smb_buffer_response);
3544 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3545 /* skip service field (NB: this field is always ASCII) */
3547 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3548 (bcc_ptr[2] == 'C')) {
3549 cFYI(1, ("IPC connection"));
3552 } else if (length == 2) {
3553 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3554 /* the most common case */
3555 cFYI(1, ("disk share connection"));
3558 bcc_ptr += length + 1;
3559 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3560 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3561 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3562 if ((bcc_ptr + (2 * length)) -
3563 pByteArea(smb_buffer_response) <=
3564 BCC(smb_buffer_response)) {
3565 kfree(tcon->nativeFileSystem);
3566 tcon->nativeFileSystem =
3567 kzalloc(length + 2, GFP_KERNEL);
3568 if (tcon->nativeFileSystem)
3570 tcon->nativeFileSystem,
3572 length, nls_codepage);
3573 bcc_ptr += 2 * length;
3574 bcc_ptr[0] = 0; /* null terminate the string */
3578 /* else do not bother copying these information fields*/
3580 length = strnlen(bcc_ptr, 1024);
3581 if ((bcc_ptr + length) -
3582 pByteArea(smb_buffer_response) <=
3583 BCC(smb_buffer_response)) {
3584 kfree(tcon->nativeFileSystem);
3585 tcon->nativeFileSystem =
3586 kzalloc(length + 1, GFP_KERNEL);
3587 if (tcon->nativeFileSystem)
3588 strncpy(tcon->nativeFileSystem, bcc_ptr,
3591 /* else do not bother copying these information fields*/
3593 if ((smb_buffer_response->WordCount == 3) ||
3594 (smb_buffer_response->WordCount == 7))
3595 /* field is in same location */
3596 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3599 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3600 } else if ((rc == 0) && tcon == NULL) {
3601 /* all we need to save for IPC$ connection */
3602 ses->ipc_tid = smb_buffer_response->Tid;
3605 cifs_buf_release(smb_buffer);
3610 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3616 cifs_put_tcon(cifs_sb->tcon);
3618 cifs_sb->tcon = NULL;
3619 tmp = cifs_sb->prepath;
3620 cifs_sb->prepathlen = 0;
3621 cifs_sb->prepath = NULL;
3627 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3628 struct nls_table *nls_info)
3631 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3632 bool ntlmv2_flag = false;
3634 struct TCP_Server_Info *server = pSesInfo->server;
3636 /* what if server changes its buffer size after dropping the session? */
3637 if (server->maxBuf == 0) /* no need to send on reconnect */ {
3638 rc = CIFSSMBNegotiate(xid, pSesInfo);
3639 if (rc == -EAGAIN) {
3640 /* retry only once on 1st time connection */
3641 rc = CIFSSMBNegotiate(xid, pSesInfo);
3646 spin_lock(&GlobalMid_Lock);
3647 if (server->tcpStatus != CifsExiting)
3648 server->tcpStatus = CifsGood;
3651 spin_unlock(&GlobalMid_Lock);
3660 pSesInfo->flags = 0;
3661 pSesInfo->capabilities = server->capabilities;
3662 if (linuxExtEnabled == 0)
3663 pSesInfo->capabilities &= (~CAP_UNIX);
3664 /* pSesInfo->sequence_number = 0;*/
3665 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3666 server->secMode, server->capabilities, server->timeAdj));
3668 if (experimEnabled < 2)
3669 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
3670 else if (extended_security
3671 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3672 && (server->secType == NTLMSSP)) {
3674 } else if (extended_security
3675 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3676 && (server->secType == RawNTLMSSP)) {
3677 cFYI(1, ("NTLMSSP sesssetup"));
3678 rc = CIFSNTLMSSPNegotiateSessSetup(xid, pSesInfo, &ntlmv2_flag,
3683 cFYI(1, ("more secure NTLM ver2 hash"));
3684 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3689 v2_response = kmalloc(16 + 64 /* blob*/,
3692 CalcNTLMv2_response(pSesInfo,
3695 cifs_calculate_ntlmv2_mac_key */
3697 /* BB Put dummy sig in SessSetup PDU? */
3704 SMBNTencrypt(pSesInfo->password,
3709 cifs_calculate_mac_key(
3710 &server->mac_signing_key,
3712 pSesInfo->password);
3714 /* for better security the weaker lanman hash not sent
3715 in AuthSessSetup so we no longer calculate it */
3717 rc = CIFSNTLMSSPAuthSessSetup(xid, pSesInfo,
3722 } else { /* old style NTLM 0.12 session setup */
3723 SMBNTencrypt(pSesInfo->password, server->cryptKey,
3727 cifs_calculate_mac_key(&server->mac_signing_key,
3729 pSesInfo->password);
3731 rc = CIFSSessSetup(xid, pSesInfo, ntlm_session_key, nls_info);
3734 cERROR(1, ("Send error in SessSetup = %d", rc));
3736 cFYI(1, ("CIFS Session Established successfully"));
3737 spin_lock(&GlobalMid_Lock);
3738 pSesInfo->status = CifsGood;
3739 pSesInfo->need_reconnect = false;
3740 spin_unlock(&GlobalMid_Lock);