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 */
96 unsigned short int port;
100 static int ipv4_connect(struct sockaddr_in *psin_server,
101 struct socket **csocket,
103 char *server_netb_name);
104 static int ipv6_connect(struct sockaddr_in6 *psin_server,
105 struct socket **csocket);
109 * cifs tcp session reconnection
111 * mark tcp session as reconnecting so temporarily locked
112 * mark all smb sessions as reconnecting for tcp session
113 * reconnect tcp session
114 * wake up waiters on reconnection? - (not needed currently)
118 cifs_reconnect(struct TCP_Server_Info *server)
121 struct list_head *tmp;
122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
124 struct mid_q_entry *mid_entry;
126 spin_lock(&GlobalMid_Lock);
127 if (kthread_should_stop()) {
128 /* the demux thread will exit normally
129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
137 cFYI(1, ("Reconnecting tcp session"));
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
141 read_lock(&GlobalSMBSeslock);
142 list_for_each(tmp, &GlobalSMBSessionList) {
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
145 if (ses->server == server) {
146 ses->status = CifsNeedReconnect;
150 /* else tcp and smb sessions need reconnection */
152 list_for_each(tmp, &GlobalTreeConnectionList) {
153 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
154 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
155 tcon->tidStatus = CifsNeedReconnect;
157 read_unlock(&GlobalSMBSeslock);
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
177 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
178 /* Mark other intransit requests as needing
179 retry so we do not immediately mark the
180 session bad again (ie after we reconnect
181 below) as they timeout too */
182 mid_entry->midState = MID_RETRY_NEEDED;
186 spin_unlock(&GlobalMid_Lock);
189 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
191 if (server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,
195 rc = ipv4_connect(&server->addr.sockAddr,
197 server->workstation_RFC1001_name,
198 server->server_RFC1001_name);
201 cFYI(1, ("reconnect error %d", rc));
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
206 if (!kthread_should_stop())
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)));
354 write_lock(&GlobalSMBSeslock);
355 atomic_inc(&tcpSesAllocCount);
356 length = tcpSesAllocCount.counter;
357 write_unlock(&GlobalSMBSeslock);
359 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
363 while (!kthread_should_stop()) {
366 if (bigbuf == NULL) {
367 bigbuf = cifs_buf_get();
369 cERROR(1, ("No memory for large SMB response"));
371 /* retry will check if exiting */
374 } else if (isLargeBuf) {
375 /* we are reusing a dirty large buf, clear its start */
376 memset(bigbuf, 0, sizeof(struct smb_hdr));
379 if (smallbuf == NULL) {
380 smallbuf = cifs_small_buf_get();
382 cERROR(1, ("No memory for SMB response"));
384 /* retry will check if exiting */
387 /* beginning of smb buffer is cleared in our buf_get */
388 } else /* if existing small buf clear beginning */
389 memset(smallbuf, 0, sizeof(struct smb_hdr));
393 smb_buffer = smallbuf;
394 iov.iov_base = smb_buffer;
396 smb_msg.msg_control = NULL;
397 smb_msg.msg_controllen = 0;
398 pdu_length = 4; /* enough to get RFC1001 header */
401 kernel_recvmsg(csocket, &smb_msg,
402 &iov, 1, pdu_length, 0 /* BB other flags? */);
404 if (kthread_should_stop()) {
406 } else if (server->tcpStatus == CifsNeedReconnect) {
407 cFYI(1, ("Reconnect after server stopped responding"));
408 cifs_reconnect(server);
409 cFYI(1, ("call to reconnect done"));
410 csocket = server->ssocket;
412 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
413 msleep(1); /* minimum sleep to prevent looping
414 allowing socket to clear and app threads to set
415 tcpStatus CifsNeedReconnect if server hung */
420 } else if (length <= 0) {
421 if (server->tcpStatus == CifsNew) {
422 cFYI(1, ("tcp session abend after SMBnegprot"));
423 /* some servers kill the TCP session rather than
424 returning an SMB negprot error, in which
425 case reconnecting here is not going to help,
426 and so simply return error to mount */
429 if (!try_to_freeze() && (length == -EINTR)) {
430 cFYI(1, ("cifsd thread killed"));
433 cFYI(1, ("Reconnect after unexpected peek error %d",
435 cifs_reconnect(server);
436 csocket = server->ssocket;
437 wake_up(&server->response_q);
439 } else if (length < pdu_length) {
440 cFYI(1, ("requested %d bytes but only got %d bytes",
441 pdu_length, length));
442 pdu_length -= length;
447 /* The right amount was read from socket - 4 bytes */
448 /* so we can now interpret the length field */
450 /* the first byte big endian of the length field,
451 is actually not part of the length but the type
452 with the most common, zero, as regular data */
453 temp = *((char *) smb_buffer);
455 /* Note that FC 1001 length is big endian on the wire,
456 but we convert it here so it is always manipulated
457 as host byte order */
458 pdu_length = ntohl(smb_buffer->smb_buf_length);
459 smb_buffer->smb_buf_length = pdu_length;
461 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
463 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
465 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
466 cFYI(1, ("Good RFC 1002 session rsp"));
468 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
469 /* we get this from Windows 98 instead of
470 an error on SMB negprot response */
471 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
473 if (server->tcpStatus == CifsNew) {
474 /* if nack on negprot (rather than
475 ret of smb negprot error) reconnecting
476 not going to help, ret error to mount */
479 /* give server a second to
480 clean up before reconnect attempt */
482 /* always try 445 first on reconnect
483 since we get NACK on some if we ever
484 connected to port 139 (the NACK is
485 since we do not begin with RFC1001
486 session initialize frame) */
487 server->addr.sockAddr.sin_port =
489 cifs_reconnect(server);
490 csocket = server->ssocket;
491 wake_up(&server->response_q);
494 } else if (temp != (char) 0) {
495 cERROR(1, ("Unknown RFC 1002 frame"));
496 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
498 cifs_reconnect(server);
499 csocket = server->ssocket;
503 /* else we have an SMB response */
504 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
505 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
506 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
507 length, pdu_length+4));
508 cifs_reconnect(server);
509 csocket = server->ssocket;
510 wake_up(&server->response_q);
517 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
519 memcpy(bigbuf, smallbuf, 4);
523 iov.iov_base = 4 + (char *)smb_buffer;
524 iov.iov_len = pdu_length;
525 for (total_read = 0; total_read < pdu_length;
526 total_read += length) {
527 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
528 pdu_length - total_read, 0);
529 if (kthread_should_stop() ||
530 (length == -EINTR)) {
534 } else if (server->tcpStatus == CifsNeedReconnect) {
535 cifs_reconnect(server);
536 csocket = server->ssocket;
537 /* Reconnect wakes up rspns q */
538 /* Now we will reread sock */
541 } else if ((length == -ERESTARTSYS) ||
542 (length == -EAGAIN)) {
543 msleep(1); /* minimum sleep to prevent looping,
544 allowing socket to clear and app
545 threads to set tcpStatus
546 CifsNeedReconnect if server hung*/
549 } else if (length <= 0) {
550 cERROR(1, ("Received no data, expecting %d",
551 pdu_length - total_read));
552 cifs_reconnect(server);
553 csocket = server->ssocket;
560 else if (reconnect == 1)
563 length += 4; /* account for rfc1002 hdr */
566 dump_smb(smb_buffer, length);
567 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
568 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
574 spin_lock(&GlobalMid_Lock);
575 list_for_each(tmp, &server->pending_mid_q) {
576 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
578 if ((mid_entry->mid == smb_buffer->Mid) &&
579 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
580 (mid_entry->command == smb_buffer->Command)) {
581 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
582 /* We have a multipart transact2 resp */
584 if (mid_entry->resp_buf) {
585 /* merge response - fix up 1st*/
586 if (coalesce_t2(smb_buffer,
587 mid_entry->resp_buf)) {
588 mid_entry->multiRsp =
592 /* all parts received */
593 mid_entry->multiEnd =
599 cERROR(1,("1st trans2 resp needs bigbuf"));
600 /* BB maybe we can fix this up, switch
601 to already allocated large buffer? */
603 /* Have first buffer */
604 mid_entry->resp_buf =
606 mid_entry->largeBuf =
613 mid_entry->resp_buf = smb_buffer;
614 mid_entry->largeBuf = isLargeBuf;
616 task_to_wake = mid_entry->tsk;
617 mid_entry->midState = MID_RESPONSE_RECEIVED;
618 #ifdef CONFIG_CIFS_STATS2
619 mid_entry->when_received = jiffies;
621 /* so we do not time out requests to server
622 which is still responding (since server could
623 be busy but not dead) */
624 server->lstrp = jiffies;
628 spin_unlock(&GlobalMid_Lock);
630 /* Was previous buf put in mpx struct for multi-rsp? */
632 /* smb buffer will be freed by user thread */
638 wake_up_process(task_to_wake);
639 } else if (!is_valid_oplock_break(smb_buffer, server) &&
641 cERROR(1, ("No task to wake, unknown frame received! "
642 "NumMids %d", midCount.counter));
643 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
644 sizeof(struct smb_hdr));
645 #ifdef CONFIG_CIFS_DEBUG2
646 cifs_dump_detail(smb_buffer);
647 cifs_dump_mids(server);
648 #endif /* CIFS_DEBUG2 */
651 } /* end while !EXITING */
653 spin_lock(&GlobalMid_Lock);
654 server->tcpStatus = CifsExiting;
655 spin_unlock(&GlobalMid_Lock);
657 /* don't exit until kthread_stop is called */
658 set_current_state(TASK_UNINTERRUPTIBLE);
659 while (!kthread_should_stop()) {
661 set_current_state(TASK_UNINTERRUPTIBLE);
663 set_current_state(TASK_RUNNING);
665 /* check if we have blocked requests that need to free */
666 /* Note that cifs_max_pending is normally 50, but
667 can be set at module install time to as little as two */
668 spin_lock(&GlobalMid_Lock);
669 if (atomic_read(&server->inFlight) >= cifs_max_pending)
670 atomic_set(&server->inFlight, cifs_max_pending - 1);
671 /* We do not want to set the max_pending too low or we
672 could end up with the counter going negative */
673 spin_unlock(&GlobalMid_Lock);
674 /* Although there should not be any requests blocked on
675 this queue it can not hurt to be paranoid and try to wake up requests
676 that may haven been blocked when more than 50 at time were on the wire
677 to the same server - they now will see the session is in exit state
678 and get out of SendReceive. */
679 wake_up_all(&server->request_q);
680 /* give those requests time to exit */
683 if (server->ssocket) {
684 sock_release(csocket);
685 server->ssocket = NULL;
687 /* buffer usuallly freed in free_mid - need to free it here on exit */
688 cifs_buf_release(bigbuf);
689 if (smallbuf) /* no sense logging a debug message if NULL */
690 cifs_small_buf_release(smallbuf);
692 read_lock(&GlobalSMBSeslock);
693 if (list_empty(&server->pending_mid_q)) {
694 /* loop through server session structures attached to this and
696 list_for_each(tmp, &GlobalSMBSessionList) {
698 list_entry(tmp, struct cifsSesInfo,
700 if (ses->server == server) {
701 ses->status = CifsExiting;
705 read_unlock(&GlobalSMBSeslock);
707 /* although we can not zero the server struct pointer yet,
708 since there are active requests which may depnd on them,
709 mark the corresponding SMB sessions as exiting too */
710 list_for_each(tmp, &GlobalSMBSessionList) {
711 ses = list_entry(tmp, struct cifsSesInfo,
713 if (ses->server == server)
714 ses->status = CifsExiting;
717 spin_lock(&GlobalMid_Lock);
718 list_for_each(tmp, &server->pending_mid_q) {
719 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
720 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
721 cFYI(1, ("Clearing Mid 0x%x - waking up ",
723 task_to_wake = mid_entry->tsk;
725 wake_up_process(task_to_wake);
728 spin_unlock(&GlobalMid_Lock);
729 read_unlock(&GlobalSMBSeslock);
730 /* 1/8th of sec is more than enough time for them to exit */
734 if (!list_empty(&server->pending_mid_q)) {
735 /* mpx threads have not exited yet give them
736 at least the smb send timeout time for long ops */
737 /* due to delays on oplock break requests, we need
738 to wait at least 45 seconds before giving up
739 on a request getting a response and going ahead
741 cFYI(1, ("Wait for exit from demultiplex thread"));
743 /* if threads still have not exited they are probably never
744 coming home not much else we can do but free the memory */
747 write_lock(&GlobalSMBSeslock);
748 atomic_dec(&tcpSesAllocCount);
749 length = tcpSesAllocCount.counter;
751 /* last chance to mark ses pointers invalid
752 if there are any pointing to this (e.g
753 if a crazy root user tried to kill cifsd
754 kernel thread explicitly this might happen) */
755 list_for_each(tmp, &GlobalSMBSessionList) {
756 ses = list_entry(tmp, struct cifsSesInfo,
758 if (ses->server == server)
761 write_unlock(&GlobalSMBSeslock);
763 kfree(server->hostname);
766 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
772 /* extract the host portion of the UNC string */
774 extract_hostname(const char *unc)
780 /* skip double chars at beginning of string */
781 /* BB: check validity of these bytes? */
784 /* delimiter between hostname and sharename is always '\\' now */
785 delim = strchr(src, '\\');
787 return ERR_PTR(-EINVAL);
790 dst = kmalloc((len + 1), GFP_KERNEL);
792 return ERR_PTR(-ENOMEM);
794 memcpy(dst, src, len);
801 cifs_parse_mount_options(char *options, const char *devname,
806 unsigned int temp_len, i, j;
812 if (Local_System_Name[0] != 0)
813 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
815 char *nodename = utsname()->nodename;
816 int n = strnlen(nodename, 15);
817 memset(vol->source_rfc1001_name, 0x20, 15);
818 for (i = 0; i < n; i++) {
819 /* does not have to be perfect mapping since field is
820 informational, only used for servers that do not support
821 port 445 and it can be overridden at mount time */
822 vol->source_rfc1001_name[i] = toupper(nodename[i]);
825 vol->source_rfc1001_name[15] = 0;
826 /* null target name indicates to use *SMBSERVR default called name
827 if we end up sending RFC1001 session initialize */
828 vol->target_rfc1001_name[0] = 0;
829 vol->linux_uid = current->uid; /* current->euid instead? */
830 vol->linux_gid = current->gid;
831 vol->dir_mode = S_IRWXUGO;
832 /* 2767 perms indicate mandatory locking support */
833 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
835 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
837 /* default is always to request posix paths. */
838 vol->posix_paths = 1;
843 if (strncmp(options, "sep=", 4) == 0) {
844 if (options[4] != 0) {
845 separator[0] = options[4];
848 cFYI(1, ("Null separator not allowed"));
852 while ((data = strsep(&options, separator)) != NULL) {
855 if ((value = strchr(data, '=')) != NULL)
858 /* Have to parse this before we parse for "user" */
859 if (strnicmp(data, "user_xattr", 10) == 0) {
861 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
863 } else if (strnicmp(data, "user", 4) == 0) {
866 "CIFS: invalid or missing username\n");
867 return 1; /* needs_arg; */
868 } else if (!*value) {
869 /* null user, ie anonymous, authentication */
872 if (strnlen(value, 200) < 200) {
873 vol->username = value;
875 printk(KERN_WARNING "CIFS: username too long\n");
878 } else if (strnicmp(data, "pass", 4) == 0) {
880 vol->password = NULL;
882 } else if (value[0] == 0) {
883 /* check if string begins with double comma
884 since that would mean the password really
885 does start with a comma, and would not
886 indicate an empty string */
887 if (value[1] != separator[0]) {
888 vol->password = NULL;
892 temp_len = strlen(value);
893 /* removed password length check, NTLM passwords
894 can be arbitrarily long */
896 /* if comma in password, the string will be
897 prematurely null terminated. Commas in password are
898 specified across the cifs mount interface by a double
899 comma ie ,, and a comma used as in other cases ie ','
900 as a parameter delimiter/separator is single and due
901 to the strsep above is temporarily zeroed. */
903 /* NB: password legally can have multiple commas and
904 the only illegal character in a password is null */
906 if ((value[temp_len] == 0) &&
907 (value[temp_len+1] == separator[0])) {
909 value[temp_len] = separator[0];
910 temp_len += 2; /* move after second comma */
911 while (value[temp_len] != 0) {
912 if (value[temp_len] == separator[0]) {
913 if (value[temp_len+1] ==
915 /* skip second comma */
918 /* single comma indicating start
925 if (value[temp_len] == 0) {
929 /* point option to start of next parm */
930 options = value + temp_len + 1;
932 /* go from value to value + temp_len condensing
933 double commas to singles. Note that this ends up
934 allocating a few bytes too many, which is ok */
935 vol->password = kzalloc(temp_len, GFP_KERNEL);
936 if (vol->password == NULL) {
937 printk(KERN_WARNING "CIFS: no memory "
941 for (i = 0, j = 0; i < temp_len; i++, j++) {
942 vol->password[j] = value[i];
943 if (value[i] == separator[0]
944 && value[i+1] == separator[0]) {
945 /* skip second comma */
949 vol->password[j] = 0;
951 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
952 if (vol->password == NULL) {
953 printk(KERN_WARNING "CIFS: no memory "
957 strcpy(vol->password, value);
959 } else if (strnicmp(data, "ip", 2) == 0) {
960 if (!value || !*value) {
962 } else if (strnlen(value, 35) < 35) {
965 printk(KERN_WARNING "CIFS: ip address "
969 } else if (strnicmp(data, "sec", 3) == 0) {
970 if (!value || !*value) {
971 cERROR(1, ("no security value specified"));
973 } else if (strnicmp(value, "krb5i", 5) == 0) {
974 vol->secFlg |= CIFSSEC_MAY_KRB5 |
976 } else if (strnicmp(value, "krb5p", 5) == 0) {
977 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
979 cERROR(1, ("Krb5 cifs privacy not supported"));
981 } else if (strnicmp(value, "krb5", 4) == 0) {
982 vol->secFlg |= CIFSSEC_MAY_KRB5;
983 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
984 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
986 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
987 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
988 } else if (strnicmp(value, "ntlmi", 5) == 0) {
989 vol->secFlg |= CIFSSEC_MAY_NTLM |
991 } else if (strnicmp(value, "ntlm", 4) == 0) {
992 /* ntlm is default so can be turned off too */
993 vol->secFlg |= CIFSSEC_MAY_NTLM;
994 } else if (strnicmp(value, "nontlm", 6) == 0) {
995 /* BB is there a better way to do this? */
996 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
997 #ifdef CONFIG_CIFS_WEAK_PW_HASH
998 } else if (strnicmp(value, "lanman", 6) == 0) {
999 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1001 } else if (strnicmp(value, "none", 4) == 0) {
1004 cERROR(1, ("bad security option: %s", value));
1007 } else if ((strnicmp(data, "unc", 3) == 0)
1008 || (strnicmp(data, "target", 6) == 0)
1009 || (strnicmp(data, "path", 4) == 0)) {
1010 if (!value || !*value) {
1011 printk(KERN_WARNING "CIFS: invalid path to "
1012 "network resource\n");
1013 return 1; /* needs_arg; */
1015 if ((temp_len = strnlen(value, 300)) < 300) {
1016 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1017 if (vol->UNC == NULL)
1019 strcpy(vol->UNC, value);
1020 if (strncmp(vol->UNC, "//", 2) == 0) {
1023 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1025 "CIFS: UNC Path does not begin "
1026 "with // or \\\\ \n");
1030 printk(KERN_WARNING "CIFS: UNC name too long\n");
1033 } else if ((strnicmp(data, "domain", 3) == 0)
1034 || (strnicmp(data, "workgroup", 5) == 0)) {
1035 if (!value || !*value) {
1036 printk(KERN_WARNING "CIFS: invalid domain name\n");
1037 return 1; /* needs_arg; */
1039 /* BB are there cases in which a comma can be valid in
1040 a domain name and need special handling? */
1041 if (strnlen(value, 256) < 256) {
1042 vol->domainname = value;
1043 cFYI(1, ("Domain name set"));
1045 printk(KERN_WARNING "CIFS: domain name too "
1049 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1050 if (!value || !*value) {
1052 "CIFS: invalid path prefix\n");
1053 return 1; /* needs_argument */
1055 if ((temp_len = strnlen(value, 1024)) < 1024) {
1056 if (value[0] != '/')
1057 temp_len++; /* missing leading slash */
1058 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1059 if (vol->prepath == NULL)
1061 if (value[0] != '/') {
1062 vol->prepath[0] = '/';
1063 strcpy(vol->prepath+1, value);
1065 strcpy(vol->prepath, value);
1066 cFYI(1, ("prefix path %s", vol->prepath));
1068 printk(KERN_WARNING "CIFS: prefix too long\n");
1071 } else if (strnicmp(data, "iocharset", 9) == 0) {
1072 if (!value || !*value) {
1073 printk(KERN_WARNING "CIFS: invalid iocharset "
1075 return 1; /* needs_arg; */
1077 if (strnlen(value, 65) < 65) {
1078 if (strnicmp(value, "default", 7))
1079 vol->iocharset = value;
1080 /* if iocharset not set then load_nls_default
1081 is used by caller */
1082 cFYI(1, ("iocharset set to %s", value));
1084 printk(KERN_WARNING "CIFS: iocharset name "
1088 } else if (strnicmp(data, "uid", 3) == 0) {
1089 if (value && *value) {
1091 simple_strtoul(value, &value, 0);
1092 vol->override_uid = 1;
1094 } else if (strnicmp(data, "gid", 3) == 0) {
1095 if (value && *value) {
1097 simple_strtoul(value, &value, 0);
1098 vol->override_gid = 1;
1100 } else if (strnicmp(data, "file_mode", 4) == 0) {
1101 if (value && *value) {
1103 simple_strtoul(value, &value, 0);
1105 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1106 if (value && *value) {
1108 simple_strtoul(value, &value, 0);
1110 } else if (strnicmp(data, "dirmode", 4) == 0) {
1111 if (value && *value) {
1113 simple_strtoul(value, &value, 0);
1115 } else if (strnicmp(data, "port", 4) == 0) {
1116 if (value && *value) {
1118 simple_strtoul(value, &value, 0);
1120 } else if (strnicmp(data, "rsize", 5) == 0) {
1121 if (value && *value) {
1123 simple_strtoul(value, &value, 0);
1125 } else if (strnicmp(data, "wsize", 5) == 0) {
1126 if (value && *value) {
1128 simple_strtoul(value, &value, 0);
1130 } else if (strnicmp(data, "sockopt", 5) == 0) {
1131 if (value && *value) {
1133 simple_strtoul(value, &value, 0);
1135 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1136 if (!value || !*value || (*value == ' ')) {
1137 cFYI(1, ("invalid (empty) netbiosname"));
1139 memset(vol->source_rfc1001_name, 0x20, 15);
1140 for (i = 0; i < 15; i++) {
1141 /* BB are there cases in which a comma can be
1142 valid in this workstation netbios name (and need
1143 special handling)? */
1145 /* We do not uppercase netbiosname for user */
1149 vol->source_rfc1001_name[i] =
1152 /* The string has 16th byte zero still from
1153 set at top of the function */
1154 if ((i == 15) && (value[i] != 0))
1155 printk(KERN_WARNING "CIFS: netbiosname"
1156 " longer than 15 truncated.\n");
1158 } else if (strnicmp(data, "servern", 7) == 0) {
1159 /* servernetbiosname specified override *SMBSERVER */
1160 if (!value || !*value || (*value == ' ')) {
1161 cFYI(1, ("empty server netbiosname specified"));
1163 /* last byte, type, is 0x20 for servr type */
1164 memset(vol->target_rfc1001_name, 0x20, 16);
1166 for (i = 0; i < 15; i++) {
1167 /* BB are there cases in which a comma can be
1168 valid in this workstation netbios name
1169 (and need special handling)? */
1171 /* user or mount helper must uppercase
1176 vol->target_rfc1001_name[i] =
1179 /* The string has 16th byte zero still from
1180 set at top of the function */
1181 if ((i == 15) && (value[i] != 0))
1182 printk(KERN_WARNING "CIFS: server net"
1183 "biosname longer than 15 truncated.\n");
1185 } else if (strnicmp(data, "credentials", 4) == 0) {
1187 } else if (strnicmp(data, "version", 3) == 0) {
1189 } else if (strnicmp(data, "guest", 5) == 0) {
1191 } else if (strnicmp(data, "rw", 2) == 0) {
1193 } else if ((strnicmp(data, "suid", 4) == 0) ||
1194 (strnicmp(data, "nosuid", 6) == 0) ||
1195 (strnicmp(data, "exec", 4) == 0) ||
1196 (strnicmp(data, "noexec", 6) == 0) ||
1197 (strnicmp(data, "nodev", 5) == 0) ||
1198 (strnicmp(data, "noauto", 6) == 0) ||
1199 (strnicmp(data, "dev", 3) == 0)) {
1200 /* The mount tool or mount.cifs helper (if present)
1201 uses these opts to set flags, and the flags are read
1202 by the kernel vfs layer before we get here (ie
1203 before read super) so there is no point trying to
1204 parse these options again and set anything and it
1205 is ok to just ignore them */
1207 } else if (strnicmp(data, "ro", 2) == 0) {
1209 } else if (strnicmp(data, "hard", 4) == 0) {
1211 } else if (strnicmp(data, "soft", 4) == 0) {
1213 } else if (strnicmp(data, "perm", 4) == 0) {
1215 } else if (strnicmp(data, "noperm", 6) == 0) {
1217 } else if (strnicmp(data, "mapchars", 8) == 0) {
1219 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1221 } else if (strnicmp(data, "sfu", 3) == 0) {
1223 } else if (strnicmp(data, "nosfu", 5) == 0) {
1225 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1226 vol->posix_paths = 1;
1227 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1228 vol->posix_paths = 0;
1229 } else if (strnicmp(data, "nounix", 6) == 0) {
1230 vol->no_linux_ext = 1;
1231 } else if (strnicmp(data, "nolinux", 7) == 0) {
1232 vol->no_linux_ext = 1;
1233 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1234 (strnicmp(data, "ignorecase", 10) == 0)) {
1236 } else if (strnicmp(data, "brl", 3) == 0) {
1238 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1239 (strnicmp(data, "nolock", 6) == 0)) {
1241 /* turn off mandatory locking in mode
1242 if remote locking is turned off since the
1243 local vfs will do advisory */
1244 if (vol->file_mode ==
1245 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1246 vol->file_mode = S_IALLUGO;
1247 } else if (strnicmp(data, "setuids", 7) == 0) {
1249 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1251 } else if (strnicmp(data, "dynperm", 7) == 0) {
1252 vol->dynperm = true;
1253 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1254 vol->dynperm = false;
1255 } else if (strnicmp(data, "nohard", 6) == 0) {
1257 } else if (strnicmp(data, "nosoft", 6) == 0) {
1259 } else if (strnicmp(data, "nointr", 6) == 0) {
1261 } else if (strnicmp(data, "intr", 4) == 0) {
1263 } else if (strnicmp(data, "serverino", 7) == 0) {
1264 vol->server_ino = 1;
1265 } else if (strnicmp(data, "noserverino", 9) == 0) {
1266 vol->server_ino = 0;
1267 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1269 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1271 } else if (strnicmp(data, "acl", 3) == 0) {
1272 vol->no_psx_acl = 0;
1273 } else if (strnicmp(data, "noacl", 5) == 0) {
1274 vol->no_psx_acl = 1;
1275 } else if (strnicmp(data, "sign", 4) == 0) {
1276 vol->secFlg |= CIFSSEC_MUST_SIGN;
1277 } else if (strnicmp(data, "seal", 4) == 0) {
1278 /* we do not do the following in secFlags because seal
1279 is a per tree connection (mount) not a per socket
1280 or per-smb connection option in the protocol */
1281 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1283 } else if (strnicmp(data, "direct", 6) == 0) {
1285 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1287 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1288 if (!value || !*value) {
1289 vol->in6_addr = NULL;
1290 } else if (strnlen(value, 49) == 48) {
1291 vol->in6_addr = value;
1293 printk(KERN_WARNING "CIFS: ip v6 address not "
1294 "48 characters long\n");
1297 } else if (strnicmp(data, "noac", 4) == 0) {
1298 printk(KERN_WARNING "CIFS: Mount option noac not "
1299 "supported. Instead set "
1300 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1302 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1305 if (vol->UNC == NULL) {
1306 if (devname == NULL) {
1307 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1311 if ((temp_len = strnlen(devname, 300)) < 300) {
1312 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1313 if (vol->UNC == NULL)
1315 strcpy(vol->UNC, devname);
1316 if (strncmp(vol->UNC, "//", 2) == 0) {
1319 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1320 printk(KERN_WARNING "CIFS: UNC Path does not "
1321 "begin with // or \\\\ \n");
1324 value = strpbrk(vol->UNC+2, "/\\");
1328 printk(KERN_WARNING "CIFS: UNC name too long\n");
1332 if (vol->UNCip == NULL)
1333 vol->UNCip = &vol->UNC[2];
1338 static struct cifsSesInfo *
1339 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1340 struct in6_addr *target_ip6_addr,
1341 char *userName, struct TCP_Server_Info **psrvTcp)
1343 struct list_head *tmp;
1344 struct cifsSesInfo *ses;
1348 read_lock(&GlobalSMBSeslock);
1349 list_for_each(tmp, &GlobalSMBSessionList) {
1350 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1354 if (target_ip_addr &&
1355 ses->server->addr.sockAddr.sin_addr.s_addr != target_ip_addr->s_addr)
1357 else if (target_ip6_addr &&
1358 memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1359 target_ip6_addr, sizeof(*target_ip6_addr)))
1361 /* BB lock server and tcp session; increment use count here?? */
1363 /* found a match on the TCP session */
1364 *psrvTcp = ses->server;
1366 /* BB check if reconnection needed */
1367 if (strncmp(ses->userName, userName, MAX_USERNAME_SIZE) == 0) {
1368 read_unlock(&GlobalSMBSeslock);
1369 /* Found exact match on both TCP and
1373 /* else tcp and smb sessions need reconnection */
1375 read_unlock(&GlobalSMBSeslock);
1380 static struct cifsTconInfo *
1381 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1383 struct list_head *tmp;
1384 struct cifsTconInfo *tcon;
1387 read_lock(&GlobalSMBSeslock);
1389 list_for_each(tmp, &GlobalTreeConnectionList) {
1390 cFYI(1, ("Next tcon"));
1391 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1392 if (!tcon->ses || !tcon->ses->server)
1395 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1396 cFYI(1, ("old ip addr: %x == new ip %x ?",
1397 old_ip, new_target_ip_addr));
1399 if (old_ip != new_target_ip_addr)
1402 /* BB lock tcon, server, tcp session and increment use count? */
1403 /* found a match on the TCP session */
1404 /* BB check if reconnection needed */
1405 cFYI(1, ("IP match, old UNC: %s new: %s",
1406 tcon->treeName, uncName));
1408 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1411 cFYI(1, ("and old usr: %s new: %s",
1412 tcon->treeName, uncName));
1414 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1417 /* matched smb session (user name) */
1418 read_unlock(&GlobalSMBSeslock);
1422 read_unlock(&GlobalSMBSeslock);
1427 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1428 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1429 struct dfs_info3_param **preferrals, int remap)
1434 *pnum_referrals = 0;
1437 if (pSesInfo->ipc_tid == 0) {
1438 temp_unc = kmalloc(2 /* for slashes */ +
1439 strnlen(pSesInfo->serverName,
1440 SERVER_NAME_LEN_WITH_NULL * 2)
1441 + 1 + 4 /* slash IPC$ */ + 2,
1443 if (temp_unc == NULL)
1447 strcpy(temp_unc + 2, pSesInfo->serverName);
1448 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1449 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1451 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1455 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1456 pnum_referrals, nls_codepage, remap);
1457 /* BB map targetUNCs to dfs_info3 structures, here or
1458 in CIFSGetDFSRefer BB */
1463 /* See RFC1001 section 14 on representation of Netbios names */
1464 static void rfc1002mangle(char *target, char *source, unsigned int length)
1468 for (i = 0, j = 0; i < (length); i++) {
1469 /* mask a nibble at a time and encode */
1470 target[j] = 'A' + (0x0F & (source[i] >> 4));
1471 target[j+1] = 'A' + (0x0F & source[i]);
1479 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1480 char *netbios_name, char *target_name)
1484 __be16 orig_port = 0;
1486 if (*csocket == NULL) {
1487 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1488 IPPROTO_TCP, csocket);
1490 cERROR(1, ("Error %d creating socket", rc));
1494 /* BB other socket options to set KEEPALIVE, NODELAY? */
1495 cFYI(1, ("Socket created"));
1496 (*csocket)->sk->sk_allocation = GFP_NOFS;
1500 psin_server->sin_family = AF_INET;
1501 if (psin_server->sin_port) { /* user overrode default port */
1502 rc = (*csocket)->ops->connect(*csocket,
1503 (struct sockaddr *) psin_server,
1504 sizeof(struct sockaddr_in), 0);
1510 /* save original port so we can retry user specified port
1511 later if fall back ports fail this time */
1512 orig_port = psin_server->sin_port;
1514 /* do not retry on the same port we just failed on */
1515 if (psin_server->sin_port != htons(CIFS_PORT)) {
1516 psin_server->sin_port = htons(CIFS_PORT);
1518 rc = (*csocket)->ops->connect(*csocket,
1519 (struct sockaddr *) psin_server,
1520 sizeof(struct sockaddr_in), 0);
1526 psin_server->sin_port = htons(RFC1001_PORT);
1527 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1529 sizeof(struct sockaddr_in), 0);
1534 /* give up here - unless we want to retry on different
1535 protocol families some day */
1538 psin_server->sin_port = orig_port;
1539 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1540 sock_release(*csocket);
1544 /* Eventually check for other socket options to change from
1545 the default. sock_setsockopt not used because it expects
1546 user space buffer */
1547 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1548 (*csocket)->sk->sk_sndbuf,
1549 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1550 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1551 /* make the bufsizes depend on wsize/rsize and max requests */
1552 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1553 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1554 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1555 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1557 /* send RFC1001 sessinit */
1558 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1559 /* some servers require RFC1001 sessinit before sending
1560 negprot - BB check reconnection in case where second
1561 sessinit is sent but no second negprot */
1562 struct rfc1002_session_packet *ses_init_buf;
1563 struct smb_hdr *smb_buf;
1564 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1567 ses_init_buf->trailer.session_req.called_len = 32;
1568 if (target_name && (target_name[0] != 0)) {
1569 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1572 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1573 DEFAULT_CIFS_CALLED_NAME, 16);
1576 ses_init_buf->trailer.session_req.calling_len = 32;
1577 /* calling name ends in null (byte 16) from old smb
1579 if (netbios_name && (netbios_name[0] != 0)) {
1580 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1583 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1584 "LINUX_CIFS_CLNT", 16);
1586 ses_init_buf->trailer.session_req.scope1 = 0;
1587 ses_init_buf->trailer.session_req.scope2 = 0;
1588 smb_buf = (struct smb_hdr *)ses_init_buf;
1589 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1590 smb_buf->smb_buf_length = 0x81000044;
1591 rc = smb_send(*csocket, smb_buf, 0x44,
1592 (struct sockaddr *)psin_server);
1593 kfree(ses_init_buf);
1594 msleep(1); /* RFC1001 layer in at least one server
1595 requires very short break before negprot
1596 presumably because not expecting negprot
1597 to follow so fast. This is a simple
1598 solution that works without
1599 complicating the code and causes no
1600 significant slowing down on mount
1601 for everyone else */
1603 /* else the negprot may still work without this
1604 even though malloc failed */
1612 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1616 __be16 orig_port = 0;
1618 if (*csocket == NULL) {
1619 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1620 IPPROTO_TCP, csocket);
1622 cERROR(1, ("Error %d creating ipv6 socket", rc));
1626 /* BB other socket options to set KEEPALIVE, NODELAY? */
1627 cFYI(1, ("ipv6 Socket created"));
1628 (*csocket)->sk->sk_allocation = GFP_NOFS;
1632 psin_server->sin6_family = AF_INET6;
1634 if (psin_server->sin6_port) { /* user overrode default port */
1635 rc = (*csocket)->ops->connect(*csocket,
1636 (struct sockaddr *) psin_server,
1637 sizeof(struct sockaddr_in6), 0);
1643 /* save original port so we can retry user specified port
1644 later if fall back ports fail this time */
1646 orig_port = psin_server->sin6_port;
1647 /* do not retry on the same port we just failed on */
1648 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1649 psin_server->sin6_port = htons(CIFS_PORT);
1651 rc = (*csocket)->ops->connect(*csocket,
1652 (struct sockaddr *) psin_server,
1653 sizeof(struct sockaddr_in6), 0);
1659 psin_server->sin6_port = htons(RFC1001_PORT);
1660 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1661 psin_server, sizeof(struct sockaddr_in6), 0);
1666 /* give up here - unless we want to retry on different
1667 protocol families some day */
1670 psin_server->sin6_port = orig_port;
1671 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1672 sock_release(*csocket);
1676 /* Eventually check for other socket options to change from
1677 the default. sock_setsockopt not used because it expects
1678 user space buffer */
1679 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1684 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1685 struct super_block *sb, struct smb_vol *vol_info)
1687 /* if we are reconnecting then should we check to see if
1688 * any requested capabilities changed locally e.g. via
1689 * remount but we can not do much about it here
1690 * if they have (even if we could detect it by the following)
1691 * Perhaps we could add a backpointer to array of sb from tcon
1692 * or if we change to make all sb to same share the same
1693 * sb as NFS - then we only have one backpointer to sb.
1694 * What if we wanted to mount the server share twice once with
1695 * and once without posixacls or posix paths? */
1696 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1698 if (vol_info && vol_info->no_linux_ext) {
1699 tcon->fsUnixInfo.Capability = 0;
1700 tcon->unix_ext = 0; /* Unix Extensions disabled */
1701 cFYI(1, ("Linux protocol extensions disabled"));
1703 } else if (vol_info)
1704 tcon->unix_ext = 1; /* Unix Extensions supported */
1706 if (tcon->unix_ext == 0) {
1707 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1711 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1712 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1714 /* check for reconnect case in which we do not
1715 want to change the mount behavior if we can avoid it */
1716 if (vol_info == NULL) {
1717 /* turn off POSIX ACL and PATHNAMES if not set
1718 originally at mount time */
1719 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1720 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1721 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1722 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1723 cERROR(1, ("POSIXPATH support change"));
1724 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1725 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1726 cERROR(1, ("possible reconnect error"));
1728 ("server disabled POSIX path support"));
1732 cap &= CIFS_UNIX_CAP_MASK;
1733 if (vol_info && vol_info->no_psx_acl)
1734 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1735 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1736 cFYI(1, ("negotiated posix acl support"));
1738 sb->s_flags |= MS_POSIXACL;
1741 if (vol_info && vol_info->posix_paths == 0)
1742 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1743 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1744 cFYI(1, ("negotiate posix pathnames"));
1746 CIFS_SB(sb)->mnt_cifs_flags |=
1747 CIFS_MOUNT_POSIX_PATHS;
1750 /* We might be setting the path sep back to a different
1751 form if we are reconnecting and the server switched its
1752 posix path capability for this share */
1753 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1754 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1756 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1757 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1758 CIFS_SB(sb)->rsize = 127 * 1024;
1760 ("larger reads not supported by srv"));
1765 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1766 #ifdef CONFIG_CIFS_DEBUG2
1767 if (cap & CIFS_UNIX_FCNTL_CAP)
1768 cFYI(1, ("FCNTL cap"));
1769 if (cap & CIFS_UNIX_EXTATTR_CAP)
1770 cFYI(1, ("EXTATTR cap"));
1771 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1772 cFYI(1, ("POSIX path cap"));
1773 if (cap & CIFS_UNIX_XATTR_CAP)
1774 cFYI(1, ("XATTR cap"));
1775 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1776 cFYI(1, ("POSIX ACL cap"));
1777 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1778 cFYI(1, ("very large read cap"));
1779 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1780 cFYI(1, ("very large write cap"));
1781 #endif /* CIFS_DEBUG2 */
1782 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1783 if (vol_info == NULL) {
1784 cFYI(1, ("resetting capabilities failed"));
1786 cERROR(1, ("Negotiating Unix capabilities "
1787 "with the server failed. Consider "
1788 "mounting with the Unix Extensions\n"
1789 "disabled, if problems are found, "
1790 "by specifying the nounix mount "
1798 convert_delimiter(char *path, char delim)
1811 for (i = 0; path[i] != '\0'; i++) {
1812 if (path[i] == old_delim)
1818 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1819 char *mount_data, const char *devname)
1823 int address_type = AF_INET;
1824 struct socket *csocket = NULL;
1825 struct sockaddr_in sin_server;
1826 struct sockaddr_in6 sin_server6;
1827 struct smb_vol volume_info;
1828 struct cifsSesInfo *pSesInfo = NULL;
1829 struct cifsSesInfo *existingCifsSes = NULL;
1830 struct cifsTconInfo *tcon = NULL;
1831 struct TCP_Server_Info *srvTcp = NULL;
1835 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1837 memset(&volume_info, 0, sizeof(struct smb_vol));
1838 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1843 if (volume_info.nullauth) {
1844 cFYI(1, ("null user"));
1845 volume_info.username = "";
1846 } else if (volume_info.username) {
1847 /* BB fixme parse for domain name here */
1848 cFYI(1, ("Username: %s", volume_info.username));
1850 cifserror("No username specified");
1851 /* In userspace mount helper we can get user name from alternate
1852 locations such as env variables and files on disk */
1857 if (volume_info.UNCip && volume_info.UNC) {
1858 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1859 &sin_server.sin_addr.s_addr);
1862 /* not ipv4 address, try ipv6 */
1863 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1864 &sin_server6.sin6_addr.in6_u);
1866 address_type = AF_INET6;
1868 address_type = AF_INET;
1872 /* we failed translating address */
1877 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1880 } else if (volume_info.UNCip) {
1881 /* BB using ip addr as server name to connect to the
1883 cERROR(1, ("Connecting to DFS root not implemented yet"));
1886 } else /* which servers DFS root would we conect to */ {
1888 ("CIFS mount error: No UNC path (e.g. -o "
1889 "unc=//192.168.1.100/public) specified"));
1894 /* this is needed for ASCII cp to Unicode converts */
1895 if (volume_info.iocharset == NULL) {
1896 cifs_sb->local_nls = load_nls_default();
1897 /* load_nls_default can not return null */
1899 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1900 if (cifs_sb->local_nls == NULL) {
1901 cERROR(1, ("CIFS mount error: iocharset %s not found",
1902 volume_info.iocharset));
1908 if (address_type == AF_INET)
1909 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1910 NULL /* no ipv6 addr */,
1911 volume_info.username, &srvTcp);
1912 else if (address_type == AF_INET6) {
1913 cFYI(1, ("looking for ipv6 address"));
1914 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1915 &sin_server6.sin6_addr,
1916 volume_info.username, &srvTcp);
1923 cFYI(1, ("Existing tcp session with server found"));
1924 } else { /* create socket */
1925 if (volume_info.port)
1926 sin_server.sin_port = htons(volume_info.port);
1928 sin_server.sin_port = 0;
1929 if (address_type == AF_INET6) {
1930 cFYI(1, ("attempting ipv6 connect"));
1931 /* BB should we allow ipv6 on port 139? */
1932 /* other OS never observed in Wild doing 139 with v6 */
1933 rc = ipv6_connect(&sin_server6, &csocket);
1935 rc = ipv4_connect(&sin_server, &csocket,
1936 volume_info.source_rfc1001_name,
1937 volume_info.target_rfc1001_name);
1939 cERROR(1, ("Error connecting to IPv4 socket. "
1940 "Aborting operation"));
1941 if (csocket != NULL)
1942 sock_release(csocket);
1946 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1949 sock_release(csocket);
1952 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1953 sizeof(struct sockaddr_in));
1954 atomic_set(&srvTcp->inFlight, 0);
1955 /* BB Add code for ipv6 case too */
1956 srvTcp->ssocket = csocket;
1957 srvTcp->protocolType = IPV4;
1958 srvTcp->hostname = extract_hostname(volume_info.UNC);
1959 if (IS_ERR(srvTcp->hostname)) {
1960 rc = PTR_ERR(srvTcp->hostname);
1961 sock_release(csocket);
1964 init_waitqueue_head(&srvTcp->response_q);
1965 init_waitqueue_head(&srvTcp->request_q);
1966 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1967 /* at this point we are the only ones with the pointer
1968 to the struct since the kernel thread not created yet
1969 so no need to spinlock this init of tcpStatus */
1970 srvTcp->tcpStatus = CifsNew;
1971 init_MUTEX(&srvTcp->tcpSem);
1972 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1973 if (IS_ERR(srvTcp->tsk)) {
1974 rc = PTR_ERR(srvTcp->tsk);
1975 cERROR(1, ("error %d create cifsd thread", rc));
1977 sock_release(csocket);
1978 kfree(srvTcp->hostname);
1982 memcpy(srvTcp->workstation_RFC1001_name,
1983 volume_info.source_rfc1001_name, 16);
1984 memcpy(srvTcp->server_RFC1001_name,
1985 volume_info.target_rfc1001_name, 16);
1986 srvTcp->sequence_number = 0;
1990 if (existingCifsSes) {
1991 pSesInfo = existingCifsSes;
1992 cFYI(1, ("Existing smb sess found (status=%d)",
1994 down(&pSesInfo->sesSem);
1995 if (pSesInfo->status == CifsNeedReconnect) {
1996 cFYI(1, ("Session needs reconnect"));
1997 rc = cifs_setup_session(xid, pSesInfo,
1998 cifs_sb->local_nls);
2000 up(&pSesInfo->sesSem);
2002 cFYI(1, ("Existing smb sess not found"));
2003 pSesInfo = sesInfoAlloc();
2004 if (pSesInfo == NULL)
2007 pSesInfo->server = srvTcp;
2008 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2009 NIPQUAD(sin_server.sin_addr.s_addr));
2013 /* volume_info.password freed at unmount */
2014 if (volume_info.password) {
2015 pSesInfo->password = volume_info.password;
2016 /* set to NULL to prevent freeing on exit */
2017 volume_info.password = NULL;
2019 if (volume_info.username)
2020 strncpy(pSesInfo->userName,
2021 volume_info.username,
2023 if (volume_info.domainname) {
2024 int len = strlen(volume_info.domainname);
2025 pSesInfo->domainName =
2026 kmalloc(len + 1, GFP_KERNEL);
2027 if (pSesInfo->domainName)
2028 strcpy(pSesInfo->domainName,
2029 volume_info.domainname);
2031 pSesInfo->linux_uid = volume_info.linux_uid;
2032 pSesInfo->overrideSecFlg = volume_info.secFlg;
2033 down(&pSesInfo->sesSem);
2034 /* BB FIXME need to pass vol->secFlgs BB */
2035 rc = cifs_setup_session(xid, pSesInfo,
2036 cifs_sb->local_nls);
2037 up(&pSesInfo->sesSem);
2039 atomic_inc(&srvTcp->socketUseCount);
2043 /* search for existing tcon to this server share */
2045 if (volume_info.rsize > CIFSMaxBufSize) {
2046 cERROR(1, ("rsize %d too large, using MaxBufSize",
2047 volume_info.rsize));
2048 cifs_sb->rsize = CIFSMaxBufSize;
2049 } else if ((volume_info.rsize) &&
2050 (volume_info.rsize <= CIFSMaxBufSize))
2051 cifs_sb->rsize = volume_info.rsize;
2053 cifs_sb->rsize = CIFSMaxBufSize;
2055 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2056 cERROR(1, ("wsize %d too large, using 4096 instead",
2057 volume_info.wsize));
2058 cifs_sb->wsize = 4096;
2059 } else if (volume_info.wsize)
2060 cifs_sb->wsize = volume_info.wsize;
2063 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2065 /* old default of CIFSMaxBufSize was too small now
2066 that SMB Write2 can send multiple pages in kvec.
2067 RFC1001 does not describe what happens when frame
2068 bigger than 128K is sent so use that as max in
2069 conjunction with 52K kvec constraint on arch with 4K
2072 if (cifs_sb->rsize < 2048) {
2073 cifs_sb->rsize = 2048;
2074 /* Windows ME may prefer this */
2075 cFYI(1, ("readsize set to minimum: 2048"));
2077 /* calculate prepath */
2078 cifs_sb->prepath = volume_info.prepath;
2079 if (cifs_sb->prepath) {
2080 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2081 /* we can not convert the / to \ in the path
2082 separators in the prefixpath yet because we do not
2083 know (until reset_cifs_unix_caps is called later)
2084 whether POSIX PATH CAP is available. We normalize
2085 the / to \ after reset_cifs_unix_caps is called */
2086 volume_info.prepath = NULL;
2088 cifs_sb->prepathlen = 0;
2089 cifs_sb->mnt_uid = volume_info.linux_uid;
2090 cifs_sb->mnt_gid = volume_info.linux_gid;
2091 cifs_sb->mnt_file_mode = volume_info.file_mode;
2092 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2093 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2094 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2096 if (volume_info.noperm)
2097 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2098 if (volume_info.setuids)
2099 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2100 if (volume_info.server_ino)
2101 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2102 if (volume_info.remap)
2103 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2104 if (volume_info.no_xattr)
2105 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2106 if (volume_info.sfu_emul)
2107 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2108 if (volume_info.nobrl)
2109 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2110 if (volume_info.cifs_acl)
2111 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2112 if (volume_info.override_uid)
2113 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2114 if (volume_info.override_gid)
2115 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2116 if (volume_info.dynperm)
2117 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2118 if (volume_info.direct_io) {
2119 cFYI(1, ("mounting share using direct i/o"));
2120 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2123 if ((volume_info.cifs_acl) && (volume_info.dynperm))
2124 cERROR(1, ("mount option dynperm ignored if cifsacl "
2125 "mount option supported"));
2128 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2129 volume_info.username);
2131 cFYI(1, ("Found match on UNC path"));
2132 /* we can have only one retry value for a connection
2133 to a share so for resources mounted more than once
2134 to the same server share the last value passed in
2135 for the retry flag is used */
2136 tcon->retry = volume_info.retry;
2137 tcon->nocase = volume_info.nocase;
2138 if (tcon->seal != volume_info.seal)
2139 cERROR(1, ("transport encryption setting "
2140 "conflicts with existing tid"));
2142 tcon = tconInfoAlloc();
2146 /* check for null share name ie connecting to
2149 /* BB check if this works for exactly length
2151 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2152 && (strchr(volume_info.UNC + 3, '/') ==
2154 /* rc = connect_to_dfs_path(xid, pSesInfo,
2155 "", cifs_sb->local_nls,
2156 cifs_sb->mnt_cifs_flags &
2157 CIFS_MOUNT_MAP_SPECIAL_CHR);*/
2158 cFYI(1, ("DFS root not supported"));
2162 /* BB Do we need to wrap sesSem around
2163 * this TCon call and Unix SetFS as
2164 * we do on SessSetup and reconnect? */
2165 rc = CIFSTCon(xid, pSesInfo,
2167 tcon, cifs_sb->local_nls);
2168 cFYI(1, ("CIFS Tcon rc = %d", rc));
2171 atomic_inc(&pSesInfo->inUse);
2172 tcon->retry = volume_info.retry;
2173 tcon->nocase = volume_info.nocase;
2174 tcon->seal = volume_info.seal;
2180 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2181 sb->s_maxbytes = (u64) 1 << 63;
2183 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2186 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2187 sb->s_time_gran = 100;
2189 /* on error free sesinfo and tcon struct if needed */
2191 /* if session setup failed, use count is zero but
2192 we still need to free cifsd thread */
2193 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2194 spin_lock(&GlobalMid_Lock);
2195 srvTcp->tcpStatus = CifsExiting;
2196 spin_unlock(&GlobalMid_Lock);
2198 /* If we could verify that kthread_stop would
2199 always wake up processes blocked in
2200 tcp in recv_mesg then we could remove the
2202 force_sig(SIGKILL, srvTcp->tsk);
2203 kthread_stop(srvTcp->tsk);
2206 /* If find_unc succeeded then rc == 0 so we can not end */
2207 if (tcon) /* up accidently freeing someone elses tcon struct */
2209 if (existingCifsSes == NULL) {
2211 if ((pSesInfo->server) &&
2212 (pSesInfo->status == CifsGood)) {
2214 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2215 /* if the socketUseCount is now zero */
2216 if ((temp_rc == -ESHUTDOWN) &&
2217 (pSesInfo->server) &&
2218 (pSesInfo->server->tsk)) {
2220 pSesInfo->server->tsk);
2221 kthread_stop(pSesInfo->server->tsk);
2224 cFYI(1, ("No session or bad tcon"));
2225 if ((pSesInfo->server) &&
2226 (pSesInfo->server->tsk)) {
2228 pSesInfo->server->tsk);
2229 kthread_stop(pSesInfo->server->tsk);
2232 sesInfoFree(pSesInfo);
2233 /* pSesInfo = NULL; */
2237 atomic_inc(&tcon->useCount);
2238 cifs_sb->tcon = tcon;
2239 tcon->ses = pSesInfo;
2241 /* do not care if following two calls succeed - informational */
2243 CIFSSMBQFSDeviceInfo(xid, tcon);
2244 CIFSSMBQFSAttributeInfo(xid, tcon);
2247 /* tell server which Unix caps we support */
2248 if (tcon->ses->capabilities & CAP_UNIX)
2249 /* reset of caps checks mount to see if unix extensions
2250 disabled for just this mount */
2251 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2253 tcon->unix_ext = 0; /* server does not support them */
2255 /* convert forward to back slashes in prepath here if needed */
2256 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2257 convert_delimiter(cifs_sb->prepath,
2258 CIFS_DIR_SEP(cifs_sb));
2260 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2261 cifs_sb->rsize = 1024 * 127;
2263 ("no very large read support, rsize now 127K"));
2265 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2266 cifs_sb->wsize = min(cifs_sb->wsize,
2267 (tcon->ses->server->maxBuf -
2268 MAX_CIFS_HDR_SIZE));
2269 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2270 cifs_sb->rsize = min(cifs_sb->rsize,
2271 (tcon->ses->server->maxBuf -
2272 MAX_CIFS_HDR_SIZE));
2275 /* volume_info.password is freed above when existing session found
2276 (in which case it is not needed anymore) but when new sesion is created
2277 the password ptr is put in the new session structure (in which case the
2278 password will be freed at unmount time) */
2280 /* zero out password before freeing */
2281 if (volume_info.password != NULL) {
2282 memset(volume_info.password, 0, strlen(volume_info.password));
2283 kfree(volume_info.password);
2285 kfree(volume_info.UNC);
2286 kfree(volume_info.prepath);
2292 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2293 char session_key[CIFS_SESS_KEY_SIZE],
2294 const struct nls_table *nls_codepage)
2296 struct smb_hdr *smb_buffer;
2297 struct smb_hdr *smb_buffer_response;
2298 SESSION_SETUP_ANDX *pSMB;
2299 SESSION_SETUP_ANDX *pSMBr;
2304 int remaining_words = 0;
2305 int bytes_returned = 0;
2310 cFYI(1, ("In sesssetup"));
2313 user = ses->userName;
2314 domain = ses->domainName;
2315 smb_buffer = cifs_buf_get();
2317 if (smb_buffer == NULL)
2320 smb_buffer_response = smb_buffer;
2321 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2323 /* send SMBsessionSetup here */
2324 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2325 NULL /* no tCon exists yet */ , 13 /* wct */ );
2327 smb_buffer->Mid = GetNextMid(ses->server);
2328 pSMB->req_no_secext.AndXCommand = 0xFF;
2329 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2330 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2332 if (ses->server->secMode &
2333 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2334 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2336 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2337 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2338 if (ses->capabilities & CAP_UNICODE) {
2339 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2340 capabilities |= CAP_UNICODE;
2342 if (ses->capabilities & CAP_STATUS32) {
2343 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2344 capabilities |= CAP_STATUS32;
2346 if (ses->capabilities & CAP_DFS) {
2347 smb_buffer->Flags2 |= SMBFLG2_DFS;
2348 capabilities |= CAP_DFS;
2350 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2352 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2353 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2355 pSMB->req_no_secext.CaseSensitivePasswordLength =
2356 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2357 bcc_ptr = pByteArea(smb_buffer);
2358 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2359 bcc_ptr += CIFS_SESS_KEY_SIZE;
2360 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2361 bcc_ptr += CIFS_SESS_KEY_SIZE;
2363 if (ses->capabilities & CAP_UNICODE) {
2364 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2369 bytes_returned = 0; /* skip null user */
2372 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2374 /* convert number of 16 bit words to bytes */
2375 bcc_ptr += 2 * bytes_returned;
2376 bcc_ptr += 2; /* trailing null */
2379 cifs_strtoUCS((__le16 *) bcc_ptr,
2380 "CIFS_LINUX_DOM", 32, nls_codepage);
2383 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2385 bcc_ptr += 2 * bytes_returned;
2388 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2390 bcc_ptr += 2 * bytes_returned;
2392 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2394 bcc_ptr += 2 * bytes_returned;
2397 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2399 bcc_ptr += 2 * bytes_returned;
2403 strncpy(bcc_ptr, user, 200);
2404 bcc_ptr += strnlen(user, 200);
2408 if (domain == NULL) {
2409 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2410 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2412 strncpy(bcc_ptr, domain, 64);
2413 bcc_ptr += strnlen(domain, 64);
2417 strcpy(bcc_ptr, "Linux version ");
2418 bcc_ptr += strlen("Linux version ");
2419 strcpy(bcc_ptr, utsname()->release);
2420 bcc_ptr += strlen(utsname()->release) + 1;
2421 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2422 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2424 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2425 smb_buffer->smb_buf_length += count;
2426 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2428 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2429 &bytes_returned, CIFS_LONG_OP);
2431 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2432 } else if ((smb_buffer_response->WordCount == 3)
2433 || (smb_buffer_response->WordCount == 4)) {
2434 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2435 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2436 if (action & GUEST_LOGIN)
2437 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2438 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2440 cFYI(1, ("UID = %d ", ses->Suid));
2441 /* response can have either 3 or 4 word count - Samba sends 3 */
2442 bcc_ptr = pByteArea(smb_buffer_response);
2443 if ((pSMBr->resp.hdr.WordCount == 3)
2444 || ((pSMBr->resp.hdr.WordCount == 4)
2445 && (blob_len < pSMBr->resp.ByteCount))) {
2446 if (pSMBr->resp.hdr.WordCount == 4)
2447 bcc_ptr += blob_len;
2449 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2450 if ((long) (bcc_ptr) % 2) {
2452 (BCC(smb_buffer_response) - 1) / 2;
2453 /* Unicode strings must be word
2458 BCC(smb_buffer_response) / 2;
2461 UniStrnlen((wchar_t *) bcc_ptr,
2462 remaining_words - 1);
2463 /* We look for obvious messed up bcc or strings in response so we do not go off
2464 the end since (at least) WIN2K and Windows XP have a major bug in not null
2465 terminating last Unicode string in response */
2467 kfree(ses->serverOS);
2468 ses->serverOS = kzalloc(2 * (len + 1),
2470 if (ses->serverOS == NULL)
2471 goto sesssetup_nomem;
2472 cifs_strfromUCS_le(ses->serverOS,
2475 bcc_ptr += 2 * (len + 1);
2476 remaining_words -= len + 1;
2477 ses->serverOS[2 * len] = 0;
2478 ses->serverOS[1 + (2 * len)] = 0;
2479 if (remaining_words > 0) {
2480 len = UniStrnlen((wchar_t *)bcc_ptr,
2482 kfree(ses->serverNOS);
2483 ses->serverNOS = kzalloc(2 * (len + 1),
2485 if (ses->serverNOS == NULL)
2486 goto sesssetup_nomem;
2487 cifs_strfromUCS_le(ses->serverNOS,
2490 bcc_ptr += 2 * (len + 1);
2491 ses->serverNOS[2 * len] = 0;
2492 ses->serverNOS[1 + (2 * len)] = 0;
2493 if (strncmp(ses->serverNOS,
2494 "NT LAN Manager 4", 16) == 0) {
2495 cFYI(1, ("NT4 server"));
2496 ses->flags |= CIFS_SES_NT4;
2498 remaining_words -= len + 1;
2499 if (remaining_words > 0) {
2500 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2501 /* last string is not always null terminated
2502 (for e.g. for Windows XP & 2000) */
2503 if (ses->serverDomain)
2504 kfree(ses->serverDomain);
2508 if (ses->serverDomain == NULL)
2509 goto sesssetup_nomem;
2510 cifs_strfromUCS_le(ses->serverDomain,
2513 bcc_ptr += 2 * (len + 1);
2514 ses->serverDomain[2*len] = 0;
2515 ses->serverDomain[1+(2*len)] = 0;
2516 } else { /* else no more room so create
2517 dummy domain string */
2518 if (ses->serverDomain)
2519 kfree(ses->serverDomain);
2521 kzalloc(2, GFP_KERNEL);
2523 } else { /* no room so create dummy domain
2526 /* if these kcallocs fail not much we
2527 can do, but better to not fail the
2529 kfree(ses->serverDomain);
2531 kzalloc(2, GFP_KERNEL);
2532 kfree(ses->serverNOS);
2534 kzalloc(2, GFP_KERNEL);
2536 } else { /* ASCII */
2537 len = strnlen(bcc_ptr, 1024);
2538 if (((long) bcc_ptr + len) - (long)
2539 pByteArea(smb_buffer_response)
2540 <= BCC(smb_buffer_response)) {
2541 kfree(ses->serverOS);
2542 ses->serverOS = kzalloc(len + 1,
2544 if (ses->serverOS == NULL)
2545 goto sesssetup_nomem;
2546 strncpy(ses->serverOS, bcc_ptr, len);
2549 /* null terminate the string */
2553 len = strnlen(bcc_ptr, 1024);
2554 kfree(ses->serverNOS);
2555 ses->serverNOS = kzalloc(len + 1,
2557 if (ses->serverNOS == NULL)
2558 goto sesssetup_nomem;
2559 strncpy(ses->serverNOS, bcc_ptr, len);
2564 len = strnlen(bcc_ptr, 1024);
2565 if (ses->serverDomain)
2566 kfree(ses->serverDomain);
2567 ses->serverDomain = kzalloc(len + 1,
2569 if (ses->serverDomain == NULL)
2570 goto sesssetup_nomem;
2571 strncpy(ses->serverDomain, bcc_ptr,
2578 ("Variable field of length %d "
2579 "extends beyond end of smb ",
2584 (" Security Blob Length extends beyond "
2589 (" Invalid Word count %d: ",
2590 smb_buffer_response->WordCount));
2593 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2594 since that could make reconnection harder, and
2595 reconnection might be needed to free memory */
2596 cifs_buf_release(smb_buffer);
2602 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2603 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2604 const struct nls_table *nls_codepage)
2606 struct smb_hdr *smb_buffer;
2607 struct smb_hdr *smb_buffer_response;
2608 SESSION_SETUP_ANDX *pSMB;
2609 SESSION_SETUP_ANDX *pSMBr;
2613 int remaining_words = 0;
2614 int bytes_returned = 0;
2616 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2617 PNEGOTIATE_MESSAGE SecurityBlob;
2618 PCHALLENGE_MESSAGE SecurityBlob2;
2619 __u32 negotiate_flags, capabilities;
2622 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2625 domain = ses->domainName;
2626 *pNTLMv2_flag = false;
2627 smb_buffer = cifs_buf_get();
2628 if (smb_buffer == NULL) {
2631 smb_buffer_response = smb_buffer;
2632 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2633 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2635 /* send SMBsessionSetup here */
2636 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2637 NULL /* no tCon exists yet */ , 12 /* wct */ );
2639 smb_buffer->Mid = GetNextMid(ses->server);
2640 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2641 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2643 pSMB->req.AndXCommand = 0xFF;
2644 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2645 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2647 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2648 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2650 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2651 CAP_EXTENDED_SECURITY;
2652 if (ses->capabilities & CAP_UNICODE) {
2653 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2654 capabilities |= CAP_UNICODE;
2656 if (ses->capabilities & CAP_STATUS32) {
2657 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2658 capabilities |= CAP_STATUS32;
2660 if (ses->capabilities & CAP_DFS) {
2661 smb_buffer->Flags2 |= SMBFLG2_DFS;
2662 capabilities |= CAP_DFS;
2664 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2666 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2667 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2668 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2669 SecurityBlob->MessageType = NtLmNegotiate;
2671 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2672 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2673 NTLMSSP_NEGOTIATE_56 |
2674 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2676 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2677 /* if (ntlmv2_support)
2678 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2679 /* setup pointers to domain name and workstation name */
2680 bcc_ptr += SecurityBlobLength;
2682 SecurityBlob->WorkstationName.Buffer = 0;
2683 SecurityBlob->WorkstationName.Length = 0;
2684 SecurityBlob->WorkstationName.MaximumLength = 0;
2686 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2687 along with username on auth request (ie the response to challenge) */
2688 SecurityBlob->DomainName.Buffer = 0;
2689 SecurityBlob->DomainName.Length = 0;
2690 SecurityBlob->DomainName.MaximumLength = 0;
2691 if (ses->capabilities & CAP_UNICODE) {
2692 if ((long) bcc_ptr % 2) {
2698 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2700 bcc_ptr += 2 * bytes_returned;
2702 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2704 bcc_ptr += 2 * bytes_returned;
2705 bcc_ptr += 2; /* null terminate Linux version */
2707 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2709 bcc_ptr += 2 * bytes_returned;
2712 bcc_ptr += 2; /* null terminate network opsys string */
2715 bcc_ptr += 2; /* null domain */
2716 } else { /* ASCII */
2717 strcpy(bcc_ptr, "Linux version ");
2718 bcc_ptr += strlen("Linux version ");
2719 strcpy(bcc_ptr, utsname()->release);
2720 bcc_ptr += strlen(utsname()->release) + 1;
2721 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2722 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2723 bcc_ptr++; /* empty domain field */
2726 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2727 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2728 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2729 smb_buffer->smb_buf_length += count;
2730 pSMB->req.ByteCount = cpu_to_le16(count);
2732 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2733 &bytes_returned, CIFS_LONG_OP);
2735 if (smb_buffer_response->Status.CifsError ==
2736 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2740 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2741 } else if ((smb_buffer_response->WordCount == 3)
2742 || (smb_buffer_response->WordCount == 4)) {
2743 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2744 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2746 if (action & GUEST_LOGIN)
2747 cFYI(1, (" Guest login"));
2748 /* Do we want to set anything in SesInfo struct when guest login? */
2750 bcc_ptr = pByteArea(smb_buffer_response);
2751 /* response can have either 3 or 4 word count - Samba sends 3 */
2753 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2754 if (SecurityBlob2->MessageType != NtLmChallenge) {
2756 ("Unexpected NTLMSSP message type received %d",
2757 SecurityBlob2->MessageType));
2759 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2760 cFYI(1, ("UID = %d", ses->Suid));
2761 if ((pSMBr->resp.hdr.WordCount == 3)
2762 || ((pSMBr->resp.hdr.WordCount == 4)
2764 pSMBr->resp.ByteCount))) {
2766 if (pSMBr->resp.hdr.WordCount == 4) {
2767 bcc_ptr += blob_len;
2768 cFYI(1, ("Security Blob Length %d",
2772 cFYI(1, ("NTLMSSP Challenge rcvd"));
2774 memcpy(ses->server->cryptKey,
2775 SecurityBlob2->Challenge,
2776 CIFS_CRYPTO_KEY_SIZE);
2777 if (SecurityBlob2->NegotiateFlags &
2778 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2779 *pNTLMv2_flag = true;
2781 if ((SecurityBlob2->NegotiateFlags &
2782 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2783 || (sign_CIFS_PDUs > 1))
2784 ses->server->secMode |=
2785 SECMODE_SIGN_REQUIRED;
2786 if ((SecurityBlob2->NegotiateFlags &
2787 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2788 ses->server->secMode |=
2789 SECMODE_SIGN_ENABLED;
2791 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2792 if ((long) (bcc_ptr) % 2) {
2794 (BCC(smb_buffer_response)
2796 /* Must word align unicode strings */
2801 (smb_buffer_response) / 2;
2804 UniStrnlen((wchar_t *) bcc_ptr,
2805 remaining_words - 1);
2806 /* We look for obvious messed up bcc or strings in response so we do not go off
2807 the end since (at least) WIN2K and Windows XP have a major bug in not null
2808 terminating last Unicode string in response */
2810 kfree(ses->serverOS);
2812 kzalloc(2 * (len + 1), GFP_KERNEL);
2813 cifs_strfromUCS_le(ses->serverOS,
2817 bcc_ptr += 2 * (len + 1);
2818 remaining_words -= len + 1;
2819 ses->serverOS[2 * len] = 0;
2820 ses->serverOS[1 + (2 * len)] = 0;
2821 if (remaining_words > 0) {
2822 len = UniStrnlen((wchar_t *)
2826 kfree(ses->serverNOS);
2828 kzalloc(2 * (len + 1),
2830 cifs_strfromUCS_le(ses->
2836 bcc_ptr += 2 * (len + 1);
2837 ses->serverNOS[2 * len] = 0;
2840 remaining_words -= len + 1;
2841 if (remaining_words > 0) {
2842 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2843 /* last string not always null terminated
2844 (for e.g. for Windows XP & 2000) */
2845 kfree(ses->serverDomain);
2857 ses->serverDomain[2*len]
2862 } /* else no more room so create dummy domain string */
2864 kfree(ses->serverDomain);
2869 } else { /* no room so create dummy domain and NOS string */
2870 kfree(ses->serverDomain);
2872 kzalloc(2, GFP_KERNEL);
2873 kfree(ses->serverNOS);
2875 kzalloc(2, GFP_KERNEL);
2877 } else { /* ASCII */
2878 len = strnlen(bcc_ptr, 1024);
2879 if (((long) bcc_ptr + len) - (long)
2880 pByteArea(smb_buffer_response)
2881 <= BCC(smb_buffer_response)) {
2883 kfree(ses->serverOS);
2887 strncpy(ses->serverOS,
2891 bcc_ptr[0] = 0; /* null terminate string */
2894 len = strnlen(bcc_ptr, 1024);
2895 kfree(ses->serverNOS);
2899 strncpy(ses->serverNOS, bcc_ptr, len);
2904 len = strnlen(bcc_ptr, 1024);
2905 kfree(ses->serverDomain);
2909 strncpy(ses->serverDomain,
2916 ("field of length %d "
2917 "extends beyond end of smb",
2921 cERROR(1, ("Security Blob Length extends beyond"
2925 cERROR(1, ("No session structure passed in."));
2929 (" Invalid Word count %d:",
2930 smb_buffer_response->WordCount));
2934 cifs_buf_release(smb_buffer);
2939 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2940 char *ntlm_session_key, bool ntlmv2_flag,
2941 const struct nls_table *nls_codepage)
2943 struct smb_hdr *smb_buffer;
2944 struct smb_hdr *smb_buffer_response;
2945 SESSION_SETUP_ANDX *pSMB;
2946 SESSION_SETUP_ANDX *pSMBr;
2951 int remaining_words = 0;
2952 int bytes_returned = 0;
2954 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2955 PAUTHENTICATE_MESSAGE SecurityBlob;
2956 __u32 negotiate_flags, capabilities;
2959 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2962 user = ses->userName;
2963 domain = ses->domainName;
2964 smb_buffer = cifs_buf_get();
2965 if (smb_buffer == NULL) {
2968 smb_buffer_response = smb_buffer;
2969 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2970 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2972 /* send SMBsessionSetup here */
2973 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2974 NULL /* no tCon exists yet */ , 12 /* wct */ );
2976 smb_buffer->Mid = GetNextMid(ses->server);
2977 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2978 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2979 pSMB->req.AndXCommand = 0xFF;
2980 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2981 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2983 pSMB->req.hdr.Uid = ses->Suid;
2985 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2986 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2988 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2989 CAP_EXTENDED_SECURITY;
2990 if (ses->capabilities & CAP_UNICODE) {
2991 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2992 capabilities |= CAP_UNICODE;
2994 if (ses->capabilities & CAP_STATUS32) {
2995 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2996 capabilities |= CAP_STATUS32;
2998 if (ses->capabilities & CAP_DFS) {
2999 smb_buffer->Flags2 |= SMBFLG2_DFS;
3000 capabilities |= CAP_DFS;
3002 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3004 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3005 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3006 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3007 SecurityBlob->MessageType = NtLmAuthenticate;
3008 bcc_ptr += SecurityBlobLength;
3009 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3010 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3011 0x80000000 | NTLMSSP_NEGOTIATE_128;
3013 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3015 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3017 /* setup pointers to domain name and workstation name */
3019 SecurityBlob->WorkstationName.Buffer = 0;
3020 SecurityBlob->WorkstationName.Length = 0;
3021 SecurityBlob->WorkstationName.MaximumLength = 0;
3022 SecurityBlob->SessionKey.Length = 0;
3023 SecurityBlob->SessionKey.MaximumLength = 0;
3024 SecurityBlob->SessionKey.Buffer = 0;
3026 SecurityBlob->LmChallengeResponse.Length = 0;
3027 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3028 SecurityBlob->LmChallengeResponse.Buffer = 0;
3030 SecurityBlob->NtChallengeResponse.Length =
3031 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3032 SecurityBlob->NtChallengeResponse.MaximumLength =
3033 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3034 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3035 SecurityBlob->NtChallengeResponse.Buffer =
3036 cpu_to_le32(SecurityBlobLength);
3037 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3038 bcc_ptr += CIFS_SESS_KEY_SIZE;
3040 if (ses->capabilities & CAP_UNICODE) {
3041 if (domain == NULL) {
3042 SecurityBlob->DomainName.Buffer = 0;
3043 SecurityBlob->DomainName.Length = 0;
3044 SecurityBlob->DomainName.MaximumLength = 0;
3046 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3049 SecurityBlob->DomainName.MaximumLength =
3051 SecurityBlob->DomainName.Buffer =
3052 cpu_to_le32(SecurityBlobLength);
3054 SecurityBlobLength += ln;
3055 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3058 SecurityBlob->UserName.Buffer = 0;
3059 SecurityBlob->UserName.Length = 0;
3060 SecurityBlob->UserName.MaximumLength = 0;
3062 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3065 SecurityBlob->UserName.MaximumLength =
3067 SecurityBlob->UserName.Buffer =
3068 cpu_to_le32(SecurityBlobLength);
3070 SecurityBlobLength += ln;
3071 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3074 /* SecurityBlob->WorkstationName.Length =
3075 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3076 SecurityBlob->WorkstationName.Length *= 2;
3077 SecurityBlob->WorkstationName.MaximumLength =
3078 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3079 SecurityBlob->WorkstationName.Buffer =
3080 cpu_to_le32(SecurityBlobLength);
3081 bcc_ptr += SecurityBlob->WorkstationName.Length;
3082 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3083 SecurityBlob->WorkstationName.Length =
3084 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3086 if ((long) bcc_ptr % 2) {
3091 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3093 bcc_ptr += 2 * bytes_returned;
3095 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3097 bcc_ptr += 2 * bytes_returned;
3098 bcc_ptr += 2; /* null term version string */
3100 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3102 bcc_ptr += 2 * bytes_returned;
3105 bcc_ptr += 2; /* null terminate network opsys string */
3108 bcc_ptr += 2; /* null domain */
3109 } else { /* ASCII */
3110 if (domain == NULL) {
3111 SecurityBlob->DomainName.Buffer = 0;
3112 SecurityBlob->DomainName.Length = 0;
3113 SecurityBlob->DomainName.MaximumLength = 0;
3116 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3117 strncpy(bcc_ptr, domain, 63);
3118 ln = strnlen(domain, 64);
3119 SecurityBlob->DomainName.MaximumLength =
3121 SecurityBlob->DomainName.Buffer =
3122 cpu_to_le32(SecurityBlobLength);
3124 SecurityBlobLength += ln;
3125 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3128 SecurityBlob->UserName.Buffer = 0;
3129 SecurityBlob->UserName.Length = 0;
3130 SecurityBlob->UserName.MaximumLength = 0;
3133 strncpy(bcc_ptr, user, 63);
3134 ln = strnlen(user, 64);
3135 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3136 SecurityBlob->UserName.Buffer =
3137 cpu_to_le32(SecurityBlobLength);
3139 SecurityBlobLength += ln;
3140 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3142 /* BB fill in our workstation name if known BB */
3144 strcpy(bcc_ptr, "Linux version ");
3145 bcc_ptr += strlen("Linux version ");
3146 strcpy(bcc_ptr, utsname()->release);
3147 bcc_ptr += strlen(utsname()->release) + 1;
3148 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3149 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3150 bcc_ptr++; /* null domain */
3153 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3154 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3155 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3156 smb_buffer->smb_buf_length += count;
3157 pSMB->req.ByteCount = cpu_to_le16(count);
3159 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3160 &bytes_returned, CIFS_LONG_OP);
3162 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3163 } else if ((smb_buffer_response->WordCount == 3) ||
3164 (smb_buffer_response->WordCount == 4)) {
3165 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3166 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3167 if (action & GUEST_LOGIN)
3168 cFYI(1, (" Guest login")); /* BB Should we set anything
3169 in SesInfo struct ? */
3170 /* if (SecurityBlob2->MessageType != NtLm??) {
3171 cFYI("Unexpected message type on auth response is %d"));
3176 ("Check challenge UID %d vs auth response UID %d",
3177 ses->Suid, smb_buffer_response->Uid));
3178 /* UID left in wire format */
3179 ses->Suid = smb_buffer_response->Uid;
3180 bcc_ptr = pByteArea(smb_buffer_response);
3181 /* response can have either 3 or 4 word count - Samba sends 3 */
3182 if ((pSMBr->resp.hdr.WordCount == 3)
3183 || ((pSMBr->resp.hdr.WordCount == 4)
3185 pSMBr->resp.ByteCount))) {
3186 if (pSMBr->resp.hdr.WordCount == 4) {
3190 ("Security Blob Length %d ",
3195 ("NTLMSSP response to Authenticate "));
3197 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3198 if ((long) (bcc_ptr) % 2) {
3200 (BCC(smb_buffer_response)
3202 bcc_ptr++; /* Unicode strings must be word aligned */
3204 remaining_words = BCC(smb_buffer_response) / 2;
3206 len = UniStrnlen((wchar_t *) bcc_ptr,
3207 remaining_words - 1);
3208 /* We look for obvious messed up bcc or strings in response so we do not go off
3209 the end since (at least) WIN2K and Windows XP have a major bug in not null
3210 terminating last Unicode string in response */
3212 kfree(ses->serverOS);
3214 kzalloc(2 * (len + 1), GFP_KERNEL);
3215 cifs_strfromUCS_le(ses->serverOS,
3219 bcc_ptr += 2 * (len + 1);
3220 remaining_words -= len + 1;
3221 ses->serverOS[2 * len] = 0;
3222 ses->serverOS[1 + (2 * len)] = 0;
3223 if (remaining_words > 0) {
3224 len = UniStrnlen((wchar_t *)
3228 kfree(ses->serverNOS);
3230 kzalloc(2 * (len + 1),
3232 cifs_strfromUCS_le(ses->
3238 bcc_ptr += 2 * (len + 1);
3239 ses->serverNOS[2 * len] = 0;
3240 ses->serverNOS[1+(2*len)] = 0;
3241 remaining_words -= len + 1;
3242 if (remaining_words > 0) {
3243 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3244 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3245 if (ses->serverDomain)
3246 kfree(ses->serverDomain);
3271 } /* else no more room so create dummy domain string */
3273 if (ses->serverDomain)
3274 kfree(ses->serverDomain);
3275 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3277 } else { /* no room so create dummy domain and NOS string */
3278 if (ses->serverDomain)
3279 kfree(ses->serverDomain);
3280 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3281 kfree(ses->serverNOS);
3282 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3284 } else { /* ASCII */
3285 len = strnlen(bcc_ptr, 1024);
3286 if (((long) bcc_ptr + len) -
3287 (long) pByteArea(smb_buffer_response)
3288 <= BCC(smb_buffer_response)) {
3290 kfree(ses->serverOS);
3291 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3292 strncpy(ses->serverOS,bcc_ptr, len);
3295 bcc_ptr[0] = 0; /* null terminate the string */
3298 len = strnlen(bcc_ptr, 1024);
3299 kfree(ses->serverNOS);
3300 ses->serverNOS = kzalloc(len+1,
3302 strncpy(ses->serverNOS,
3308 len = strnlen(bcc_ptr, 1024);
3309 if (ses->serverDomain)
3310 kfree(ses->serverDomain);
3314 strncpy(ses->serverDomain,
3320 cFYI(1, ("field of length %d "
3321 "extends beyond end of smb ",
3325 cERROR(1, ("Security Blob extends beyond end "
3329 cERROR(1, ("No session structure passed in."));
3332 cERROR(1, ("Invalid Word count %d: ",
3333 smb_buffer_response->WordCount));
3337 cifs_buf_release(smb_buffer);
3343 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3344 const char *tree, struct cifsTconInfo *tcon,
3345 const struct nls_table *nls_codepage)
3347 struct smb_hdr *smb_buffer;
3348 struct smb_hdr *smb_buffer_response;
3351 unsigned char *bcc_ptr;
3359 smb_buffer = cifs_buf_get();
3360 if (smb_buffer == NULL) {
3363 smb_buffer_response = smb_buffer;
3365 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3366 NULL /*no tid */ , 4 /*wct */ );
3368 smb_buffer->Mid = GetNextMid(ses->server);
3369 smb_buffer->Uid = ses->Suid;
3370 pSMB = (TCONX_REQ *) smb_buffer;
3371 pSMBr = (TCONX_RSP *) smb_buffer_response;
3373 pSMB->AndXCommand = 0xFF;
3374 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3375 bcc_ptr = &pSMB->Password[0];
3376 if ((ses->server->secMode) & SECMODE_USER) {
3377 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3378 *bcc_ptr = 0; /* password is null byte */
3379 bcc_ptr++; /* skip password */
3380 /* already aligned so no need to do it below */
3382 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3383 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3384 specified as required (when that support is added to
3385 the vfs in the future) as only NTLM or the much
3386 weaker LANMAN (which we do not send by default) is accepted
3387 by Samba (not sure whether other servers allow
3388 NTLMv2 password here) */
3389 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3390 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3391 (ses->server->secType == LANMAN))
3392 calc_lanman_hash(ses, bcc_ptr);
3394 #endif /* CIFS_WEAK_PW_HASH */
3395 SMBNTencrypt(ses->password,
3396 ses->server->cryptKey,
3399 bcc_ptr += CIFS_SESS_KEY_SIZE;
3400 if (ses->capabilities & CAP_UNICODE) {
3401 /* must align unicode strings */
3402 *bcc_ptr = 0; /* null byte password */
3407 if (ses->server->secMode &
3408 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3409 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3411 if (ses->capabilities & CAP_STATUS32) {
3412 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3414 if (ses->capabilities & CAP_DFS) {
3415 smb_buffer->Flags2 |= SMBFLG2_DFS;
3417 if (ses->capabilities & CAP_UNICODE) {
3418 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3420 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3421 6 /* max utf8 char length in bytes */ *
3422 (/* server len*/ + 256 /* share len */), nls_codepage);
3423 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3424 bcc_ptr += 2; /* skip trailing null */
3425 } else { /* ASCII */
3426 strcpy(bcc_ptr, tree);
3427 bcc_ptr += strlen(tree) + 1;
3429 strcpy(bcc_ptr, "?????");
3430 bcc_ptr += strlen("?????");
3432 count = bcc_ptr - &pSMB->Password[0];
3433 pSMB->hdr.smb_buf_length += count;
3434 pSMB->ByteCount = cpu_to_le16(count);
3436 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3439 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3440 /* above now done in SendReceive */
3441 if ((rc == 0) && (tcon != NULL)) {
3442 tcon->tidStatus = CifsGood;
3443 tcon->tid = smb_buffer_response->Tid;
3444 bcc_ptr = pByteArea(smb_buffer_response);
3445 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3446 /* skip service field (NB: this field is always ASCII) */
3448 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3449 (bcc_ptr[2] == 'C')) {
3450 cFYI(1, ("IPC connection"));
3453 } else if (length == 2) {
3454 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3455 /* the most common case */
3456 cFYI(1, ("disk share connection"));
3459 bcc_ptr += length + 1;
3460 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3461 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3462 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3463 if ((bcc_ptr + (2 * length)) -
3464 pByteArea(smb_buffer_response) <=
3465 BCC(smb_buffer_response)) {
3466 kfree(tcon->nativeFileSystem);
3467 tcon->nativeFileSystem =
3468 kzalloc(length + 2, GFP_KERNEL);
3469 if (tcon->nativeFileSystem)
3471 tcon->nativeFileSystem,
3473 length, nls_codepage);
3474 bcc_ptr += 2 * length;
3475 bcc_ptr[0] = 0; /* null terminate the string */
3479 /* else do not bother copying these information fields*/
3481 length = strnlen(bcc_ptr, 1024);
3482 if ((bcc_ptr + length) -
3483 pByteArea(smb_buffer_response) <=
3484 BCC(smb_buffer_response)) {
3485 kfree(tcon->nativeFileSystem);
3486 tcon->nativeFileSystem =
3487 kzalloc(length + 1, GFP_KERNEL);
3488 if (tcon->nativeFileSystem)
3489 strncpy(tcon->nativeFileSystem, bcc_ptr,
3492 /* else do not bother copying these information fields*/
3494 if ((smb_buffer_response->WordCount == 3) ||
3495 (smb_buffer_response->WordCount == 7))
3496 /* field is in same location */
3497 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3500 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3501 } else if ((rc == 0) && tcon == NULL) {
3502 /* all we need to save for IPC$ connection */
3503 ses->ipc_tid = smb_buffer_response->Tid;
3506 cifs_buf_release(smb_buffer);
3511 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3515 struct cifsSesInfo *ses = NULL;
3516 struct task_struct *cifsd_task;
3521 if (cifs_sb->tcon) {
3522 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3523 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3528 DeleteTconOplockQEntries(cifs_sb->tcon);
3529 tconInfoFree(cifs_sb->tcon);
3530 if ((ses) && (ses->server)) {
3531 /* save off task so we do not refer to ses later */
3532 cifsd_task = ses->server->tsk;
3533 cFYI(1, ("About to do SMBLogoff "));
3534 rc = CIFSSMBLogoff(xid, ses);
3538 } else if (rc == -ESHUTDOWN) {
3539 cFYI(1, ("Waking up socket by sending signal"));
3541 force_sig(SIGKILL, cifsd_task);
3542 kthread_stop(cifsd_task);
3545 } /* else - we have an smb session
3546 left on this socket do not kill cifsd */
3548 cFYI(1, ("No session or bad tcon"));
3551 cifs_sb->tcon = NULL;
3552 tmp = cifs_sb->prepath;
3553 cifs_sb->prepathlen = 0;
3554 cifs_sb->prepath = NULL;
3563 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3564 struct nls_table *nls_info)
3567 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3568 bool ntlmv2_flag = false;
3571 /* what if server changes its buffer size after dropping the session? */
3572 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3573 rc = CIFSSMBNegotiate(xid, pSesInfo);
3574 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3575 rc = CIFSSMBNegotiate(xid, pSesInfo);
3580 spin_lock(&GlobalMid_Lock);
3581 if (pSesInfo->server->tcpStatus != CifsExiting)
3582 pSesInfo->server->tcpStatus = CifsGood;
3585 spin_unlock(&GlobalMid_Lock);
3591 pSesInfo->flags = 0;
3592 pSesInfo->capabilities = pSesInfo->server->capabilities;
3593 if (linuxExtEnabled == 0)
3594 pSesInfo->capabilities &= (~CAP_UNIX);
3595 /* pSesInfo->sequence_number = 0;*/
3597 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3598 pSesInfo->server->secMode,
3599 pSesInfo->server->capabilities,
3600 pSesInfo->server->timeAdj));
3601 if (experimEnabled < 2)
3602 rc = CIFS_SessSetup(xid, pSesInfo,
3603 first_time, nls_info);
3604 else if (extended_security
3605 && (pSesInfo->capabilities
3606 & CAP_EXTENDED_SECURITY)
3607 && (pSesInfo->server->secType == NTLMSSP)) {
3609 } else if (extended_security
3610 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3611 && (pSesInfo->server->secType == RawNTLMSSP)) {
3612 cFYI(1, ("NTLMSSP sesssetup"));
3613 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3620 cFYI(1, ("more secure NTLM ver2 hash"));
3621 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3626 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3628 CalcNTLMv2_response(pSesInfo,
3631 cifs_calculate_ntlmv2_mac_key(
3632 pSesInfo->server->mac_signing_key,
3633 response, ntlm_session_key,*/
3635 /* BB Put dummy sig in SessSetup PDU? */
3642 SMBNTencrypt(pSesInfo->password,
3643 pSesInfo->server->cryptKey,
3647 cifs_calculate_mac_key(
3648 &pSesInfo->server->mac_signing_key,
3650 pSesInfo->password);
3652 /* for better security the weaker lanman hash not sent
3653 in AuthSessSetup so we no longer calculate it */
3655 rc = CIFSNTLMSSPAuthSessSetup(xid,
3661 } else { /* old style NTLM 0.12 session setup */
3662 SMBNTencrypt(pSesInfo->password,
3663 pSesInfo->server->cryptKey,
3667 cifs_calculate_mac_key(
3668 &pSesInfo->server->mac_signing_key,
3669 ntlm_session_key, pSesInfo->password);
3671 rc = CIFSSessSetup(xid, pSesInfo,
3672 ntlm_session_key, nls_info);
3675 cERROR(1, ("Send error in SessSetup = %d", rc));
3677 cFYI(1, ("CIFS Session Established successfully"));
3678 pSesInfo->status = CifsGood;