4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 extern mempool_t *cifs_req_poolp;
63 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
64 char *iocharset; /* local code page for mapping to and from Unicode */
65 char source_rfc1001_name[16]; /* netbios name of client */
66 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
79 bool no_psx_acl:1; /* set if posix acl support should be disabled */
81 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
82 bool server_ino:1; /* use inode numbers from server ie UniqueId */
84 bool remap:1; /* set to remap seven reserved chars in filenames */
85 bool posix_paths:1; /* unset to not ask for posix pathnames. */
88 bool nullauth:1; /* attempt to authenticate with null user */
89 unsigned nocase; /* request case insensitive filenames */
90 unsigned nobrl; /* disable sending byte range locks to srv */
94 unsigned short int port;
98 static int ipv4_connect(struct sockaddr_in *psin_server,
99 struct socket **csocket,
101 char *server_netb_name);
102 static int ipv6_connect(struct sockaddr_in6 *psin_server,
103 struct socket **csocket);
107 * cifs tcp session reconnection
109 * mark tcp session as reconnecting so temporarily locked
110 * mark all smb sessions as reconnecting for tcp session
111 * reconnect tcp session
112 * wake up waiters on reconnection? - (not needed currently)
116 cifs_reconnect(struct TCP_Server_Info *server)
119 struct list_head *tmp;
120 struct cifsSesInfo *ses;
121 struct cifsTconInfo *tcon;
122 struct mid_q_entry *mid_entry;
124 spin_lock(&GlobalMid_Lock);
125 if (kthread_should_stop()) {
126 /* the demux thread will exit normally
127 next time through the loop */
128 spin_unlock(&GlobalMid_Lock);
131 server->tcpStatus = CifsNeedReconnect;
132 spin_unlock(&GlobalMid_Lock);
135 cFYI(1, ("Reconnecting tcp session"));
137 /* before reconnecting the tcp session, mark the smb session (uid)
138 and the tid bad so they are not used until reconnected */
139 read_lock(&GlobalSMBSeslock);
140 list_for_each(tmp, &GlobalSMBSessionList) {
141 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
143 if (ses->server == server) {
144 ses->status = CifsNeedReconnect;
148 /* else tcp and smb sessions need reconnection */
150 list_for_each(tmp, &GlobalTreeConnectionList) {
151 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
152 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
153 tcon->tidStatus = CifsNeedReconnect;
155 read_unlock(&GlobalSMBSeslock);
156 /* do not want to be sending data on a socket we are freeing */
157 down(&server->tcpSem);
158 if (server->ssocket) {
159 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
160 server->ssocket->flags));
161 kernel_sock_shutdown(server->ssocket, SHUT_WR);
162 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
163 server->ssocket->state,
164 server->ssocket->flags));
165 sock_release(server->ssocket);
166 server->ssocket = NULL;
169 spin_lock(&GlobalMid_Lock);
170 list_for_each(tmp, &server->pending_mid_q) {
171 mid_entry = list_entry(tmp, struct
175 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
176 /* Mark other intransit requests as needing
177 retry so we do not immediately mark the
178 session bad again (ie after we reconnect
179 below) as they timeout too */
180 mid_entry->midState = MID_RETRY_NEEDED;
184 spin_unlock(&GlobalMid_Lock);
187 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
189 if (server->protocolType == IPV6) {
190 rc = ipv6_connect(&server->addr.sockAddr6,
193 rc = ipv4_connect(&server->addr.sockAddr,
195 server->workstation_RFC1001_name,
196 server->server_RFC1001_name);
199 cFYI(1, ("reconnect error %d", rc));
202 atomic_inc(&tcpSesReconnectCount);
203 spin_lock(&GlobalMid_Lock);
204 if (!kthread_should_stop())
205 server->tcpStatus = CifsGood;
206 server->sequence_number = 0;
207 spin_unlock(&GlobalMid_Lock);
208 /* atomic_set(&server->inFlight,0);*/
209 wake_up(&server->response_q);
217 0 not a transact2, or all data present
218 >0 transact2 with that much data missing
219 -EINVAL = invalid transact2
222 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
224 struct smb_t2_rsp *pSMBt;
226 int data_in_this_rsp;
229 if (pSMB->Command != SMB_COM_TRANSACTION2)
232 /* check for plausible wct, bcc and t2 data and parm sizes */
233 /* check for parm and data offset going beyond end of smb */
234 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
235 cFYI(1, ("invalid transact2 word count"));
239 pSMBt = (struct smb_t2_rsp *)pSMB;
241 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
242 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
244 remaining = total_data_size - data_in_this_rsp;
248 else if (remaining < 0) {
249 cFYI(1, ("total data %d smaller than data in frame %d",
250 total_data_size, data_in_this_rsp));
253 cFYI(1, ("missing %d bytes from transact2, check next response",
255 if (total_data_size > maxBufSize) {
256 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
257 total_data_size, maxBufSize));
264 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
266 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
267 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
272 char *data_area_of_target;
273 char *data_area_of_buf2;
276 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
278 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
279 cFYI(1, ("total data size of primary and secondary t2 differ"));
282 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
284 remaining = total_data_size - total_in_buf;
289 if (remaining == 0) /* nothing to do, ignore */
292 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
293 if (remaining < total_in_buf2) {
294 cFYI(1, ("transact2 2nd response contains too much data"));
297 /* find end of first SMB data area */
298 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
299 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
300 /* validate target area */
302 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
303 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
305 data_area_of_target += total_in_buf;
307 /* copy second buffer into end of first buffer */
308 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
309 total_in_buf += total_in_buf2;
310 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
311 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
312 byte_count += total_in_buf2;
313 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
315 byte_count = pTargetSMB->smb_buf_length;
316 byte_count += total_in_buf2;
318 /* BB also add check that we are not beyond maximum buffer size */
320 pTargetSMB->smb_buf_length = byte_count;
322 if (remaining == total_in_buf2) {
323 cFYI(1, ("found the last secondary response"));
324 return 0; /* we are done */
325 } else /* more responses to go */
331 cifs_demultiplex_thread(struct TCP_Server_Info *server)
334 unsigned int pdu_length, total_read;
335 struct smb_hdr *smb_buffer = NULL;
336 struct smb_hdr *bigbuf = NULL;
337 struct smb_hdr *smallbuf = NULL;
338 struct msghdr smb_msg;
340 struct socket *csocket = server->ssocket;
341 struct list_head *tmp;
342 struct cifsSesInfo *ses;
343 struct task_struct *task_to_wake = NULL;
344 struct mid_q_entry *mid_entry;
346 bool isLargeBuf = false;
350 current->flags |= PF_MEMALLOC;
351 server->tsk = current; /* save process info to wake at shutdown */
352 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
353 write_lock(&GlobalSMBSeslock);
354 atomic_inc(&tcpSesAllocCount);
355 length = tcpSesAllocCount.counter;
356 write_unlock(&GlobalSMBSeslock);
358 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
362 while (!kthread_should_stop()) {
365 if (bigbuf == NULL) {
366 bigbuf = cifs_buf_get();
368 cERROR(1, ("No memory for large SMB response"));
370 /* retry will check if exiting */
373 } else if (isLargeBuf) {
374 /* we are reusing a dirty large buf, clear its start */
375 memset(bigbuf, 0, sizeof(struct smb_hdr));
378 if (smallbuf == NULL) {
379 smallbuf = cifs_small_buf_get();
381 cERROR(1, ("No memory for SMB response"));
383 /* retry will check if exiting */
386 /* beginning of smb buffer is cleared in our buf_get */
387 } else /* if existing small buf clear beginning */
388 memset(smallbuf, 0, sizeof(struct smb_hdr));
392 smb_buffer = smallbuf;
393 iov.iov_base = smb_buffer;
395 smb_msg.msg_control = NULL;
396 smb_msg.msg_controllen = 0;
397 pdu_length = 4; /* enough to get RFC1001 header */
400 kernel_recvmsg(csocket, &smb_msg,
401 &iov, 1, pdu_length, 0 /* BB other flags? */);
403 if (kthread_should_stop()) {
405 } else if (server->tcpStatus == CifsNeedReconnect) {
406 cFYI(1, ("Reconnect after server stopped responding"));
407 cifs_reconnect(server);
408 cFYI(1, ("call to reconnect done"));
409 csocket = server->ssocket;
411 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
412 msleep(1); /* minimum sleep to prevent looping
413 allowing socket to clear and app threads to set
414 tcpStatus CifsNeedReconnect if server hung */
419 } else if (length <= 0) {
420 if (server->tcpStatus == CifsNew) {
421 cFYI(1, ("tcp session abend after SMBnegprot"));
422 /* some servers kill the TCP session rather than
423 returning an SMB negprot error, in which
424 case reconnecting here is not going to help,
425 and so simply return error to mount */
428 if (!try_to_freeze() && (length == -EINTR)) {
429 cFYI(1, ("cifsd thread killed"));
432 cFYI(1, ("Reconnect after unexpected peek error %d",
434 cifs_reconnect(server);
435 csocket = server->ssocket;
436 wake_up(&server->response_q);
438 } else if (length < pdu_length) {
439 cFYI(1, ("requested %d bytes but only got %d bytes",
440 pdu_length, length));
441 pdu_length -= length;
446 /* The right amount was read from socket - 4 bytes */
447 /* so we can now interpret the length field */
449 /* the first byte big endian of the length field,
450 is actually not part of the length but the type
451 with the most common, zero, as regular data */
452 temp = *((char *) smb_buffer);
454 /* Note that FC 1001 length is big endian on the wire,
455 but we convert it here so it is always manipulated
456 as host byte order */
457 pdu_length = ntohl(smb_buffer->smb_buf_length);
458 smb_buffer->smb_buf_length = pdu_length;
460 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
462 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
464 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
465 cFYI(1, ("Good RFC 1002 session rsp"));
467 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
468 /* we get this from Windows 98 instead of
469 an error on SMB negprot response */
470 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
472 if (server->tcpStatus == CifsNew) {
473 /* if nack on negprot (rather than
474 ret of smb negprot error) reconnecting
475 not going to help, ret error to mount */
478 /* give server a second to
479 clean up before reconnect attempt */
481 /* always try 445 first on reconnect
482 since we get NACK on some if we ever
483 connected to port 139 (the NACK is
484 since we do not begin with RFC1001
485 session initialize frame) */
486 server->addr.sockAddr.sin_port =
488 cifs_reconnect(server);
489 csocket = server->ssocket;
490 wake_up(&server->response_q);
493 } else if (temp != (char) 0) {
494 cERROR(1, ("Unknown RFC 1002 frame"));
495 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
497 cifs_reconnect(server);
498 csocket = server->ssocket;
502 /* else we have an SMB response */
503 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
504 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
505 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
506 length, pdu_length+4));
507 cifs_reconnect(server);
508 csocket = server->ssocket;
509 wake_up(&server->response_q);
516 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
518 memcpy(bigbuf, smallbuf, 4);
522 iov.iov_base = 4 + (char *)smb_buffer;
523 iov.iov_len = pdu_length;
524 for (total_read = 0; total_read < pdu_length;
525 total_read += length) {
526 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
527 pdu_length - total_read, 0);
528 if (kthread_should_stop() ||
529 (length == -EINTR)) {
533 } else if (server->tcpStatus == CifsNeedReconnect) {
534 cifs_reconnect(server);
535 csocket = server->ssocket;
536 /* Reconnect wakes up rspns q */
537 /* Now we will reread sock */
540 } else if ((length == -ERESTARTSYS) ||
541 (length == -EAGAIN)) {
542 msleep(1); /* minimum sleep to prevent looping,
543 allowing socket to clear and app
544 threads to set tcpStatus
545 CifsNeedReconnect if server hung*/
548 } else if (length <= 0) {
549 cERROR(1, ("Received no data, expecting %d",
550 pdu_length - total_read));
551 cifs_reconnect(server);
552 csocket = server->ssocket;
559 else if (reconnect == 1)
562 length += 4; /* account for rfc1002 hdr */
565 dump_smb(smb_buffer, length);
566 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
567 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
573 spin_lock(&GlobalMid_Lock);
574 list_for_each(tmp, &server->pending_mid_q) {
575 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
577 if ((mid_entry->mid == smb_buffer->Mid) &&
578 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
579 (mid_entry->command == smb_buffer->Command)) {
580 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
581 /* We have a multipart transact2 resp */
583 if (mid_entry->resp_buf) {
584 /* merge response - fix up 1st*/
585 if (coalesce_t2(smb_buffer,
586 mid_entry->resp_buf)) {
587 mid_entry->multiRsp =
591 /* all parts received */
592 mid_entry->multiEnd =
598 cERROR(1,("1st trans2 resp needs bigbuf"));
599 /* BB maybe we can fix this up, switch
600 to already allocated large buffer? */
602 /* Have first buffer */
603 mid_entry->resp_buf =
605 mid_entry->largeBuf =
612 mid_entry->resp_buf = smb_buffer;
613 mid_entry->largeBuf = isLargeBuf;
615 task_to_wake = mid_entry->tsk;
616 mid_entry->midState = MID_RESPONSE_RECEIVED;
617 #ifdef CONFIG_CIFS_STATS2
618 mid_entry->when_received = jiffies;
620 /* so we do not time out requests to server
621 which is still responding (since server could
622 be busy but not dead) */
623 server->lstrp = jiffies;
627 spin_unlock(&GlobalMid_Lock);
629 /* Was previous buf put in mpx struct for multi-rsp? */
631 /* smb buffer will be freed by user thread */
637 wake_up_process(task_to_wake);
638 } else if (!is_valid_oplock_break(smb_buffer, server) &&
640 cERROR(1, ("No task to wake, unknown frame received! "
641 "NumMids %d", midCount.counter));
642 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
643 sizeof(struct smb_hdr));
644 #ifdef CONFIG_CIFS_DEBUG2
645 cifs_dump_detail(smb_buffer);
646 cifs_dump_mids(server);
647 #endif /* CIFS_DEBUG2 */
650 } /* end while !EXITING */
652 spin_lock(&GlobalMid_Lock);
653 server->tcpStatus = CifsExiting;
655 /* check if we have blocked requests that need to free */
656 /* Note that cifs_max_pending is normally 50, but
657 can be set at module install time to as little as two */
658 if (atomic_read(&server->inFlight) >= cifs_max_pending)
659 atomic_set(&server->inFlight, cifs_max_pending - 1);
660 /* We do not want to set the max_pending too low or we
661 could end up with the counter going negative */
662 spin_unlock(&GlobalMid_Lock);
663 /* Although there should not be any requests blocked on
664 this queue it can not hurt to be paranoid and try to wake up requests
665 that may haven been blocked when more than 50 at time were on the wire
666 to the same server - they now will see the session is in exit state
667 and get out of SendReceive. */
668 wake_up_all(&server->request_q);
669 /* give those requests time to exit */
672 if (server->ssocket) {
673 sock_release(csocket);
674 server->ssocket = NULL;
676 /* buffer usuallly freed in free_mid - need to free it here on exit */
677 cifs_buf_release(bigbuf);
678 if (smallbuf) /* no sense logging a debug message if NULL */
679 cifs_small_buf_release(smallbuf);
681 read_lock(&GlobalSMBSeslock);
682 if (list_empty(&server->pending_mid_q)) {
683 /* loop through server session structures attached to this and
685 list_for_each(tmp, &GlobalSMBSessionList) {
687 list_entry(tmp, struct cifsSesInfo,
689 if (ses->server == server) {
690 ses->status = CifsExiting;
694 read_unlock(&GlobalSMBSeslock);
696 /* although we can not zero the server struct pointer yet,
697 since there are active requests which may depnd on them,
698 mark the corresponding SMB sessions as exiting too */
699 list_for_each(tmp, &GlobalSMBSessionList) {
700 ses = list_entry(tmp, struct cifsSesInfo,
702 if (ses->server == server)
703 ses->status = CifsExiting;
706 spin_lock(&GlobalMid_Lock);
707 list_for_each(tmp, &server->pending_mid_q) {
708 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
709 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
710 cFYI(1, ("Clearing Mid 0x%x - waking up ",
712 task_to_wake = mid_entry->tsk;
714 wake_up_process(task_to_wake);
717 spin_unlock(&GlobalMid_Lock);
718 read_unlock(&GlobalSMBSeslock);
719 /* 1/8th of sec is more than enough time for them to exit */
723 if (!list_empty(&server->pending_mid_q)) {
724 /* mpx threads have not exited yet give them
725 at least the smb send timeout time for long ops */
726 /* due to delays on oplock break requests, we need
727 to wait at least 45 seconds before giving up
728 on a request getting a response and going ahead
730 cFYI(1, ("Wait for exit from demultiplex thread"));
732 /* if threads still have not exited they are probably never
733 coming home not much else we can do but free the memory */
736 write_lock(&GlobalSMBSeslock);
737 atomic_dec(&tcpSesAllocCount);
738 length = tcpSesAllocCount.counter;
740 /* last chance to mark ses pointers invalid
741 if there are any pointing to this (e.g
742 if a crazy root user tried to kill cifsd
743 kernel thread explicitly this might happen) */
744 list_for_each(tmp, &GlobalSMBSessionList) {
745 ses = list_entry(tmp, struct cifsSesInfo,
747 if (ses->server == server)
750 write_unlock(&GlobalSMBSeslock);
752 kfree(server->hostname);
755 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
761 /* extract the host portion of the UNC string */
763 extract_hostname(const char *unc)
769 /* skip double chars at beginning of string */
770 /* BB: check validity of these bytes? */
773 /* delimiter between hostname and sharename is always '\\' now */
774 delim = strchr(src, '\\');
776 return ERR_PTR(-EINVAL);
779 dst = kmalloc((len + 1), GFP_KERNEL);
781 return ERR_PTR(-ENOMEM);
783 memcpy(dst, src, len);
790 cifs_parse_mount_options(char *options, const char *devname,
795 unsigned int temp_len, i, j;
801 if (Local_System_Name[0] != 0)
802 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
804 char *nodename = utsname()->nodename;
805 int n = strnlen(nodename, 15);
806 memset(vol->source_rfc1001_name, 0x20, 15);
807 for (i = 0; i < n; i++) {
808 /* does not have to be perfect mapping since field is
809 informational, only used for servers that do not support
810 port 445 and it can be overridden at mount time */
811 vol->source_rfc1001_name[i] = toupper(nodename[i]);
814 vol->source_rfc1001_name[15] = 0;
815 /* null target name indicates to use *SMBSERVR default called name
816 if we end up sending RFC1001 session initialize */
817 vol->target_rfc1001_name[0] = 0;
818 vol->linux_uid = current->uid; /* current->euid instead? */
819 vol->linux_gid = current->gid;
820 vol->dir_mode = S_IRWXUGO;
821 /* 2767 perms indicate mandatory locking support */
822 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
824 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
826 /* default is always to request posix paths. */
827 vol->posix_paths = 1;
832 if (strncmp(options, "sep=", 4) == 0) {
833 if (options[4] != 0) {
834 separator[0] = options[4];
837 cFYI(1, ("Null separator not allowed"));
841 while ((data = strsep(&options, separator)) != NULL) {
844 if ((value = strchr(data, '=')) != NULL)
847 /* Have to parse this before we parse for "user" */
848 if (strnicmp(data, "user_xattr", 10) == 0) {
850 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
852 } else if (strnicmp(data, "user", 4) == 0) {
855 "CIFS: invalid or missing username\n");
856 return 1; /* needs_arg; */
857 } else if (!*value) {
858 /* null user, ie anonymous, authentication */
861 if (strnlen(value, 200) < 200) {
862 vol->username = value;
864 printk(KERN_WARNING "CIFS: username too long\n");
867 } else if (strnicmp(data, "pass", 4) == 0) {
869 vol->password = NULL;
871 } else if (value[0] == 0) {
872 /* check if string begins with double comma
873 since that would mean the password really
874 does start with a comma, and would not
875 indicate an empty string */
876 if (value[1] != separator[0]) {
877 vol->password = NULL;
881 temp_len = strlen(value);
882 /* removed password length check, NTLM passwords
883 can be arbitrarily long */
885 /* if comma in password, the string will be
886 prematurely null terminated. Commas in password are
887 specified across the cifs mount interface by a double
888 comma ie ,, and a comma used as in other cases ie ','
889 as a parameter delimiter/separator is single and due
890 to the strsep above is temporarily zeroed. */
892 /* NB: password legally can have multiple commas and
893 the only illegal character in a password is null */
895 if ((value[temp_len] == 0) &&
896 (value[temp_len+1] == separator[0])) {
898 value[temp_len] = separator[0];
899 temp_len += 2; /* move after second comma */
900 while (value[temp_len] != 0) {
901 if (value[temp_len] == separator[0]) {
902 if (value[temp_len+1] ==
904 /* skip second comma */
907 /* single comma indicating start
914 if (value[temp_len] == 0) {
918 /* point option to start of next parm */
919 options = value + temp_len + 1;
921 /* go from value to value + temp_len condensing
922 double commas to singles. Note that this ends up
923 allocating a few bytes too many, which is ok */
924 vol->password = kzalloc(temp_len, GFP_KERNEL);
925 if (vol->password == NULL) {
926 printk(KERN_WARNING "CIFS: no memory "
930 for (i = 0, j = 0; i < temp_len; i++, j++) {
931 vol->password[j] = value[i];
932 if (value[i] == separator[0]
933 && value[i+1] == separator[0]) {
934 /* skip second comma */
938 vol->password[j] = 0;
940 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
941 if (vol->password == NULL) {
942 printk(KERN_WARNING "CIFS: no memory "
946 strcpy(vol->password, value);
948 } else if (strnicmp(data, "ip", 2) == 0) {
949 if (!value || !*value) {
951 } else if (strnlen(value, 35) < 35) {
954 printk(KERN_WARNING "CIFS: ip address "
958 } else if (strnicmp(data, "sec", 3) == 0) {
959 if (!value || !*value) {
960 cERROR(1, ("no security value specified"));
962 } else if (strnicmp(value, "krb5i", 5) == 0) {
963 vol->secFlg |= CIFSSEC_MAY_KRB5 |
965 } else if (strnicmp(value, "krb5p", 5) == 0) {
966 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
968 cERROR(1, ("Krb5 cifs privacy not supported"));
970 } else if (strnicmp(value, "krb5", 4) == 0) {
971 vol->secFlg |= CIFSSEC_MAY_KRB5;
972 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
973 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
975 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
976 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
977 } else if (strnicmp(value, "ntlmi", 5) == 0) {
978 vol->secFlg |= CIFSSEC_MAY_NTLM |
980 } else if (strnicmp(value, "ntlm", 4) == 0) {
981 /* ntlm is default so can be turned off too */
982 vol->secFlg |= CIFSSEC_MAY_NTLM;
983 } else if (strnicmp(value, "nontlm", 6) == 0) {
984 /* BB is there a better way to do this? */
985 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
986 #ifdef CONFIG_CIFS_WEAK_PW_HASH
987 } else if (strnicmp(value, "lanman", 6) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_LANMAN;
990 } else if (strnicmp(value, "none", 4) == 0) {
993 cERROR(1, ("bad security option: %s", value));
996 } else if ((strnicmp(data, "unc", 3) == 0)
997 || (strnicmp(data, "target", 6) == 0)
998 || (strnicmp(data, "path", 4) == 0)) {
999 if (!value || !*value) {
1000 printk(KERN_WARNING "CIFS: invalid path to "
1001 "network resource\n");
1002 return 1; /* needs_arg; */
1004 if ((temp_len = strnlen(value, 300)) < 300) {
1005 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1006 if (vol->UNC == NULL)
1008 strcpy(vol->UNC, value);
1009 if (strncmp(vol->UNC, "//", 2) == 0) {
1012 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1014 "CIFS: UNC Path does not begin "
1015 "with // or \\\\ \n");
1019 printk(KERN_WARNING "CIFS: UNC name too long\n");
1022 } else if ((strnicmp(data, "domain", 3) == 0)
1023 || (strnicmp(data, "workgroup", 5) == 0)) {
1024 if (!value || !*value) {
1025 printk(KERN_WARNING "CIFS: invalid domain name\n");
1026 return 1; /* needs_arg; */
1028 /* BB are there cases in which a comma can be valid in
1029 a domain name and need special handling? */
1030 if (strnlen(value, 256) < 256) {
1031 vol->domainname = value;
1032 cFYI(1, ("Domain name set"));
1034 printk(KERN_WARNING "CIFS: domain name too "
1038 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1039 if (!value || !*value) {
1041 "CIFS: invalid path prefix\n");
1042 return 1; /* needs_argument */
1044 if ((temp_len = strnlen(value, 1024)) < 1024) {
1045 if (value[0] != '/')
1046 temp_len++; /* missing leading slash */
1047 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1048 if (vol->prepath == NULL)
1050 if (value[0] != '/') {
1051 vol->prepath[0] = '/';
1052 strcpy(vol->prepath+1, value);
1054 strcpy(vol->prepath, value);
1055 cFYI(1, ("prefix path %s", vol->prepath));
1057 printk(KERN_WARNING "CIFS: prefix too long\n");
1060 } else if (strnicmp(data, "iocharset", 9) == 0) {
1061 if (!value || !*value) {
1062 printk(KERN_WARNING "CIFS: invalid iocharset "
1064 return 1; /* needs_arg; */
1066 if (strnlen(value, 65) < 65) {
1067 if (strnicmp(value, "default", 7))
1068 vol->iocharset = value;
1069 /* if iocharset not set then load_nls_default
1070 is used by caller */
1071 cFYI(1, ("iocharset set to %s", value));
1073 printk(KERN_WARNING "CIFS: iocharset name "
1077 } else if (strnicmp(data, "uid", 3) == 0) {
1078 if (value && *value) {
1080 simple_strtoul(value, &value, 0);
1081 vol->override_uid = 1;
1083 } else if (strnicmp(data, "gid", 3) == 0) {
1084 if (value && *value) {
1086 simple_strtoul(value, &value, 0);
1087 vol->override_gid = 1;
1089 } else if (strnicmp(data, "file_mode", 4) == 0) {
1090 if (value && *value) {
1092 simple_strtoul(value, &value, 0);
1094 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1095 if (value && *value) {
1097 simple_strtoul(value, &value, 0);
1099 } else if (strnicmp(data, "dirmode", 4) == 0) {
1100 if (value && *value) {
1102 simple_strtoul(value, &value, 0);
1104 } else if (strnicmp(data, "port", 4) == 0) {
1105 if (value && *value) {
1107 simple_strtoul(value, &value, 0);
1109 } else if (strnicmp(data, "rsize", 5) == 0) {
1110 if (value && *value) {
1112 simple_strtoul(value, &value, 0);
1114 } else if (strnicmp(data, "wsize", 5) == 0) {
1115 if (value && *value) {
1117 simple_strtoul(value, &value, 0);
1119 } else if (strnicmp(data, "sockopt", 5) == 0) {
1120 if (value && *value) {
1122 simple_strtoul(value, &value, 0);
1124 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1125 if (!value || !*value || (*value == ' ')) {
1126 cFYI(1, ("invalid (empty) netbiosname"));
1128 memset(vol->source_rfc1001_name, 0x20, 15);
1129 for (i = 0; i < 15; i++) {
1130 /* BB are there cases in which a comma can be
1131 valid in this workstation netbios name (and need
1132 special handling)? */
1134 /* We do not uppercase netbiosname for user */
1138 vol->source_rfc1001_name[i] =
1141 /* The string has 16th byte zero still from
1142 set at top of the function */
1143 if ((i == 15) && (value[i] != 0))
1144 printk(KERN_WARNING "CIFS: netbiosname"
1145 " longer than 15 truncated.\n");
1147 } else if (strnicmp(data, "servern", 7) == 0) {
1148 /* servernetbiosname specified override *SMBSERVER */
1149 if (!value || !*value || (*value == ' ')) {
1150 cFYI(1, ("empty server netbiosname specified"));
1152 /* last byte, type, is 0x20 for servr type */
1153 memset(vol->target_rfc1001_name, 0x20, 16);
1155 for (i = 0; i < 15; i++) {
1156 /* BB are there cases in which a comma can be
1157 valid in this workstation netbios name
1158 (and need special handling)? */
1160 /* user or mount helper must uppercase
1165 vol->target_rfc1001_name[i] =
1168 /* The string has 16th byte zero still from
1169 set at top of the function */
1170 if ((i == 15) && (value[i] != 0))
1171 printk(KERN_WARNING "CIFS: server net"
1172 "biosname longer than 15 truncated.\n");
1174 } else if (strnicmp(data, "credentials", 4) == 0) {
1176 } else if (strnicmp(data, "version", 3) == 0) {
1178 } else if (strnicmp(data, "guest", 5) == 0) {
1180 } else if (strnicmp(data, "rw", 2) == 0) {
1182 } else if ((strnicmp(data, "suid", 4) == 0) ||
1183 (strnicmp(data, "nosuid", 6) == 0) ||
1184 (strnicmp(data, "exec", 4) == 0) ||
1185 (strnicmp(data, "noexec", 6) == 0) ||
1186 (strnicmp(data, "nodev", 5) == 0) ||
1187 (strnicmp(data, "noauto", 6) == 0) ||
1188 (strnicmp(data, "dev", 3) == 0)) {
1189 /* The mount tool or mount.cifs helper (if present)
1190 uses these opts to set flags, and the flags are read
1191 by the kernel vfs layer before we get here (ie
1192 before read super) so there is no point trying to
1193 parse these options again and set anything and it
1194 is ok to just ignore them */
1196 } else if (strnicmp(data, "ro", 2) == 0) {
1198 } else if (strnicmp(data, "hard", 4) == 0) {
1200 } else if (strnicmp(data, "soft", 4) == 0) {
1202 } else if (strnicmp(data, "perm", 4) == 0) {
1204 } else if (strnicmp(data, "noperm", 6) == 0) {
1206 } else if (strnicmp(data, "mapchars", 8) == 0) {
1208 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1210 } else if (strnicmp(data, "sfu", 3) == 0) {
1212 } else if (strnicmp(data, "nosfu", 5) == 0) {
1214 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1215 vol->posix_paths = 1;
1216 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1217 vol->posix_paths = 0;
1218 } else if (strnicmp(data, "nounix", 6) == 0) {
1219 vol->no_linux_ext = 1;
1220 } else if (strnicmp(data, "nolinux", 7) == 0) {
1221 vol->no_linux_ext = 1;
1222 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1223 (strnicmp(data, "ignorecase", 10) == 0)) {
1225 } else if (strnicmp(data, "brl", 3) == 0) {
1227 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1228 (strnicmp(data, "nolock", 6) == 0)) {
1230 /* turn off mandatory locking in mode
1231 if remote locking is turned off since the
1232 local vfs will do advisory */
1233 if (vol->file_mode ==
1234 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1235 vol->file_mode = S_IALLUGO;
1236 } else if (strnicmp(data, "setuids", 7) == 0) {
1238 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1240 } else if (strnicmp(data, "nohard", 6) == 0) {
1242 } else if (strnicmp(data, "nosoft", 6) == 0) {
1244 } else if (strnicmp(data, "nointr", 6) == 0) {
1246 } else if (strnicmp(data, "intr", 4) == 0) {
1248 } else if (strnicmp(data, "serverino", 7) == 0) {
1249 vol->server_ino = 1;
1250 } else if (strnicmp(data, "noserverino", 9) == 0) {
1251 vol->server_ino = 0;
1252 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1254 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1256 } else if (strnicmp(data, "acl", 3) == 0) {
1257 vol->no_psx_acl = 0;
1258 } else if (strnicmp(data, "noacl", 5) == 0) {
1259 vol->no_psx_acl = 1;
1260 } else if (strnicmp(data, "sign", 4) == 0) {
1261 vol->secFlg |= CIFSSEC_MUST_SIGN;
1262 /* } else if (strnicmp(data, "seal",4) == 0) {
1263 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1264 } else if (strnicmp(data, "direct", 6) == 0) {
1266 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1268 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1269 if (!value || !*value) {
1270 vol->in6_addr = NULL;
1271 } else if (strnlen(value, 49) == 48) {
1272 vol->in6_addr = value;
1274 printk(KERN_WARNING "CIFS: ip v6 address not "
1275 "48 characters long\n");
1278 } else if (strnicmp(data, "noac", 4) == 0) {
1279 printk(KERN_WARNING "CIFS: Mount option noac not "
1280 "supported. Instead set "
1281 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1283 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1286 if (vol->UNC == NULL) {
1287 if (devname == NULL) {
1288 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1292 if ((temp_len = strnlen(devname, 300)) < 300) {
1293 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1294 if (vol->UNC == NULL)
1296 strcpy(vol->UNC, devname);
1297 if (strncmp(vol->UNC, "//", 2) == 0) {
1300 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1301 printk(KERN_WARNING "CIFS: UNC Path does not "
1302 "begin with // or \\\\ \n");
1305 value = strpbrk(vol->UNC+2, "/\\");
1309 printk(KERN_WARNING "CIFS: UNC name too long\n");
1313 if (vol->UNCip == NULL)
1314 vol->UNCip = &vol->UNC[2];
1319 static struct cifsSesInfo *
1320 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1321 struct in6_addr *target_ip6_addr,
1322 char *userName, struct TCP_Server_Info **psrvTcp)
1324 struct list_head *tmp;
1325 struct cifsSesInfo *ses;
1327 read_lock(&GlobalSMBSeslock);
1329 list_for_each(tmp, &GlobalSMBSessionList) {
1330 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1332 if ((target_ip_addr &&
1333 (ses->server->addr.sockAddr.sin_addr.s_addr
1334 == target_ip_addr->s_addr)) || (target_ip6_addr
1335 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1336 target_ip6_addr, sizeof(*target_ip6_addr)))) {
1337 /* BB lock server and tcp session and increment
1340 /* found a match on the TCP session */
1341 *psrvTcp = ses->server;
1343 /* BB check if reconnection needed */
1345 (ses->userName, userName,
1346 MAX_USERNAME_SIZE) == 0){
1347 read_unlock(&GlobalSMBSeslock);
1348 /* Found exact match on both TCP and
1354 /* else tcp and smb sessions need reconnection */
1356 read_unlock(&GlobalSMBSeslock);
1360 static struct cifsTconInfo *
1361 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1363 struct list_head *tmp;
1364 struct cifsTconInfo *tcon;
1367 read_lock(&GlobalSMBSeslock);
1369 list_for_each(tmp, &GlobalTreeConnectionList) {
1370 cFYI(1, ("Next tcon"));
1371 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1372 if (!tcon->ses || !tcon->ses->server)
1375 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1376 cFYI(1, ("old ip addr: %x == new ip %x ?",
1377 old_ip, new_target_ip_addr));
1379 if (old_ip != new_target_ip_addr)
1382 /* BB lock tcon, server, tcp session and increment use count? */
1383 /* found a match on the TCP session */
1384 /* BB check if reconnection needed */
1385 cFYI(1, ("IP match, old UNC: %s new: %s",
1386 tcon->treeName, uncName));
1388 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1391 cFYI(1, ("and old usr: %s new: %s",
1392 tcon->treeName, uncName));
1394 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1397 /* matched smb session (user name) */
1398 read_unlock(&GlobalSMBSeslock);
1402 read_unlock(&GlobalSMBSeslock);
1407 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1408 const char *old_path, const struct nls_table *nls_codepage,
1411 struct dfs_info3_param *referrals = NULL;
1412 unsigned int num_referrals;
1415 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
1416 &num_referrals, &referrals, remap);
1418 /* BB Add in code to: if valid refrl, if not ip address contact
1419 the helper that resolves tcp names, mount to it, try to
1420 tcon to it unmount it if fail */
1428 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1429 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1430 struct dfs_info3_param **preferrals, int remap)
1434 unsigned char *targetUNCs;
1436 *pnum_referrals = 0;
1439 if (pSesInfo->ipc_tid == 0) {
1440 temp_unc = kmalloc(2 /* for slashes */ +
1441 strnlen(pSesInfo->serverName,
1442 SERVER_NAME_LEN_WITH_NULL * 2)
1443 + 1 + 4 /* slash IPC$ */ + 2,
1445 if (temp_unc == NULL)
1449 strcpy(temp_unc + 2, pSesInfo->serverName);
1450 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1451 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1453 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1457 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
1458 pnum_referrals, nls_codepage, remap);
1459 /* BB map targetUNCs to dfs_info3 structures, here or
1460 in CIFSGetDFSRefer BB */
1465 /* See RFC1001 section 14 on representation of Netbios names */
1466 static void rfc1002mangle(char *target, char *source, unsigned int length)
1470 for (i = 0, j = 0; i < (length); i++) {
1471 /* mask a nibble at a time and encode */
1472 target[j] = 'A' + (0x0F & (source[i] >> 4));
1473 target[j+1] = 'A' + (0x0F & source[i]);
1481 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1482 char *netbios_name, char *target_name)
1486 __be16 orig_port = 0;
1488 if (*csocket == NULL) {
1489 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1490 IPPROTO_TCP, csocket);
1492 cERROR(1, ("Error %d creating socket", rc));
1496 /* BB other socket options to set KEEPALIVE, NODELAY? */
1497 cFYI(1, ("Socket created"));
1498 (*csocket)->sk->sk_allocation = GFP_NOFS;
1502 psin_server->sin_family = AF_INET;
1503 if (psin_server->sin_port) { /* user overrode default port */
1504 rc = (*csocket)->ops->connect(*csocket,
1505 (struct sockaddr *) psin_server,
1506 sizeof(struct sockaddr_in), 0);
1512 /* save original port so we can retry user specified port
1513 later if fall back ports fail this time */
1514 orig_port = psin_server->sin_port;
1516 /* do not retry on the same port we just failed on */
1517 if (psin_server->sin_port != htons(CIFS_PORT)) {
1518 psin_server->sin_port = htons(CIFS_PORT);
1520 rc = (*csocket)->ops->connect(*csocket,
1521 (struct sockaddr *) psin_server,
1522 sizeof(struct sockaddr_in), 0);
1528 psin_server->sin_port = htons(RFC1001_PORT);
1529 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1531 sizeof(struct sockaddr_in), 0);
1536 /* give up here - unless we want to retry on different
1537 protocol families some day */
1540 psin_server->sin_port = orig_port;
1541 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1542 sock_release(*csocket);
1546 /* Eventually check for other socket options to change from
1547 the default. sock_setsockopt not used because it expects
1548 user space buffer */
1549 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1550 (*csocket)->sk->sk_sndbuf,
1551 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1552 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1553 /* make the bufsizes depend on wsize/rsize and max requests */
1554 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1555 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1556 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1557 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1559 /* send RFC1001 sessinit */
1560 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1561 /* some servers require RFC1001 sessinit before sending
1562 negprot - BB check reconnection in case where second
1563 sessinit is sent but no second negprot */
1564 struct rfc1002_session_packet *ses_init_buf;
1565 struct smb_hdr *smb_buf;
1566 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1569 ses_init_buf->trailer.session_req.called_len = 32;
1570 if (target_name && (target_name[0] != 0)) {
1571 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1574 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1575 DEFAULT_CIFS_CALLED_NAME, 16);
1578 ses_init_buf->trailer.session_req.calling_len = 32;
1579 /* calling name ends in null (byte 16) from old smb
1581 if (netbios_name && (netbios_name[0] != 0)) {
1582 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1585 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1586 "LINUX_CIFS_CLNT", 16);
1588 ses_init_buf->trailer.session_req.scope1 = 0;
1589 ses_init_buf->trailer.session_req.scope2 = 0;
1590 smb_buf = (struct smb_hdr *)ses_init_buf;
1591 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1592 smb_buf->smb_buf_length = 0x81000044;
1593 rc = smb_send(*csocket, smb_buf, 0x44,
1594 (struct sockaddr *)psin_server);
1595 kfree(ses_init_buf);
1596 msleep(1); /* RFC1001 layer in at least one server
1597 requires very short break before negprot
1598 presumably because not expecting negprot
1599 to follow so fast. This is a simple
1600 solution that works without
1601 complicating the code and causes no
1602 significant slowing down on mount
1603 for everyone else */
1605 /* else the negprot may still work without this
1606 even though malloc failed */
1614 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1618 __be16 orig_port = 0;
1620 if (*csocket == NULL) {
1621 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1622 IPPROTO_TCP, csocket);
1624 cERROR(1, ("Error %d creating ipv6 socket", rc));
1628 /* BB other socket options to set KEEPALIVE, NODELAY? */
1629 cFYI(1, ("ipv6 Socket created"));
1630 (*csocket)->sk->sk_allocation = GFP_NOFS;
1634 psin_server->sin6_family = AF_INET6;
1636 if (psin_server->sin6_port) { /* user overrode default port */
1637 rc = (*csocket)->ops->connect(*csocket,
1638 (struct sockaddr *) psin_server,
1639 sizeof(struct sockaddr_in6), 0);
1645 /* save original port so we can retry user specified port
1646 later if fall back ports fail this time */
1648 orig_port = psin_server->sin6_port;
1649 /* do not retry on the same port we just failed on */
1650 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1651 psin_server->sin6_port = htons(CIFS_PORT);
1653 rc = (*csocket)->ops->connect(*csocket,
1654 (struct sockaddr *) psin_server,
1655 sizeof(struct sockaddr_in6), 0);
1661 psin_server->sin6_port = htons(RFC1001_PORT);
1662 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1663 psin_server, sizeof(struct sockaddr_in6), 0);
1668 /* give up here - unless we want to retry on different
1669 protocol families some day */
1672 psin_server->sin6_port = orig_port;
1673 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1674 sock_release(*csocket);
1678 /* Eventually check for other socket options to change from
1679 the default. sock_setsockopt not used because it expects
1680 user space buffer */
1681 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1686 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1687 struct super_block *sb, struct smb_vol *vol_info)
1689 /* if we are reconnecting then should we check to see if
1690 * any requested capabilities changed locally e.g. via
1691 * remount but we can not do much about it here
1692 * if they have (even if we could detect it by the following)
1693 * Perhaps we could add a backpointer to array of sb from tcon
1694 * or if we change to make all sb to same share the same
1695 * sb as NFS - then we only have one backpointer to sb.
1696 * What if we wanted to mount the server share twice once with
1697 * and once without posixacls or posix paths? */
1698 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1700 if (vol_info && vol_info->no_linux_ext) {
1701 tcon->fsUnixInfo.Capability = 0;
1702 tcon->unix_ext = 0; /* Unix Extensions disabled */
1703 cFYI(1, ("Linux protocol extensions disabled"));
1705 } else if (vol_info)
1706 tcon->unix_ext = 1; /* Unix Extensions supported */
1708 if (tcon->unix_ext == 0) {
1709 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1713 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1714 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1716 /* check for reconnect case in which we do not
1717 want to change the mount behavior if we can avoid it */
1718 if (vol_info == NULL) {
1719 /* turn off POSIX ACL and PATHNAMES if not set
1720 originally at mount time */
1721 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1722 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1723 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1724 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1725 cERROR(1, ("POSIXPATH support change"));
1726 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1727 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1728 cERROR(1, ("possible reconnect error"));
1730 ("server disabled POSIX path support"));
1734 cap &= CIFS_UNIX_CAP_MASK;
1735 if (vol_info && vol_info->no_psx_acl)
1736 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1737 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1738 cFYI(1, ("negotiated posix acl support"));
1740 sb->s_flags |= MS_POSIXACL;
1743 if (vol_info && vol_info->posix_paths == 0)
1744 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1745 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1746 cFYI(1, ("negotiate posix pathnames"));
1748 CIFS_SB(sb)->mnt_cifs_flags |=
1749 CIFS_MOUNT_POSIX_PATHS;
1752 /* We might be setting the path sep back to a different
1753 form if we are reconnecting and the server switched its
1754 posix path capability for this share */
1755 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1756 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1758 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1759 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1760 CIFS_SB(sb)->rsize = 127 * 1024;
1762 ("larger reads not supported by srv"));
1767 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1768 #ifdef CONFIG_CIFS_DEBUG2
1769 if (cap & CIFS_UNIX_FCNTL_CAP)
1770 cFYI(1, ("FCNTL cap"));
1771 if (cap & CIFS_UNIX_EXTATTR_CAP)
1772 cFYI(1, ("EXTATTR cap"));
1773 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1774 cFYI(1, ("POSIX path cap"));
1775 if (cap & CIFS_UNIX_XATTR_CAP)
1776 cFYI(1, ("XATTR cap"));
1777 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1778 cFYI(1, ("POSIX ACL cap"));
1779 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1780 cFYI(1, ("very large read cap"));
1781 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1782 cFYI(1, ("very large write cap"));
1783 #endif /* CIFS_DEBUG2 */
1784 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1785 if (vol_info == NULL) {
1786 cFYI(1, ("resetting capabilities failed"));
1788 cERROR(1, ("Negotiating Unix capabilities "
1789 "with the server failed. Consider "
1790 "mounting with the Unix Extensions\n"
1791 "disabled, if problems are found, "
1792 "by specifying the nounix mount "
1800 convert_delimiter(char *path, char delim)
1813 for (i = 0; path[i] != '\0'; i++) {
1814 if (path[i] == old_delim)
1820 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1821 char *mount_data, const char *devname)
1825 int address_type = AF_INET;
1826 struct socket *csocket = NULL;
1827 struct sockaddr_in sin_server;
1828 struct sockaddr_in6 sin_server6;
1829 struct smb_vol volume_info;
1830 struct cifsSesInfo *pSesInfo = NULL;
1831 struct cifsSesInfo *existingCifsSes = NULL;
1832 struct cifsTconInfo *tcon = NULL;
1833 struct TCP_Server_Info *srvTcp = NULL;
1837 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1839 memset(&volume_info, 0, sizeof(struct smb_vol));
1840 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1845 if (volume_info.nullauth) {
1846 cFYI(1, ("null user"));
1847 volume_info.username = "";
1848 } else if (volume_info.username) {
1849 /* BB fixme parse for domain name here */
1850 cFYI(1, ("Username: %s", volume_info.username));
1852 cifserror("No username specified");
1853 /* In userspace mount helper we can get user name from alternate
1854 locations such as env variables and files on disk */
1859 if (volume_info.UNCip && volume_info.UNC) {
1860 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1861 &sin_server.sin_addr.s_addr);
1864 /* not ipv4 address, try ipv6 */
1865 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1866 &sin_server6.sin6_addr.in6_u);
1868 address_type = AF_INET6;
1870 address_type = AF_INET;
1874 /* we failed translating address */
1879 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1882 } else if (volume_info.UNCip) {
1883 /* BB using ip addr as server name to connect to the
1885 cERROR(1, ("Connecting to DFS root not implemented yet"));
1888 } else /* which servers DFS root would we conect to */ {
1890 ("CIFS mount error: No UNC path (e.g. -o "
1891 "unc=//192.168.1.100/public) specified"));
1896 /* this is needed for ASCII cp to Unicode converts */
1897 if (volume_info.iocharset == NULL) {
1898 cifs_sb->local_nls = load_nls_default();
1899 /* load_nls_default can not return null */
1901 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1902 if (cifs_sb->local_nls == NULL) {
1903 cERROR(1, ("CIFS mount error: iocharset %s not found",
1904 volume_info.iocharset));
1910 if (address_type == AF_INET)
1911 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1912 NULL /* no ipv6 addr */,
1913 volume_info.username, &srvTcp);
1914 else if (address_type == AF_INET6) {
1915 cFYI(1, ("looking for ipv6 address"));
1916 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1917 &sin_server6.sin6_addr,
1918 volume_info.username, &srvTcp);
1925 cFYI(1, ("Existing tcp session with server found"));
1926 } else { /* create socket */
1927 if (volume_info.port)
1928 sin_server.sin_port = htons(volume_info.port);
1930 sin_server.sin_port = 0;
1931 if (address_type == AF_INET6) {
1932 cFYI(1, ("attempting ipv6 connect"));
1933 /* BB should we allow ipv6 on port 139? */
1934 /* other OS never observed in Wild doing 139 with v6 */
1935 rc = ipv6_connect(&sin_server6, &csocket);
1937 rc = ipv4_connect(&sin_server, &csocket,
1938 volume_info.source_rfc1001_name,
1939 volume_info.target_rfc1001_name);
1941 cERROR(1, ("Error connecting to IPv4 socket. "
1942 "Aborting operation"));
1943 if (csocket != NULL)
1944 sock_release(csocket);
1948 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1951 sock_release(csocket);
1954 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1955 sizeof(struct sockaddr_in));
1956 atomic_set(&srvTcp->inFlight, 0);
1957 /* BB Add code for ipv6 case too */
1958 srvTcp->ssocket = csocket;
1959 srvTcp->protocolType = IPV4;
1960 srvTcp->hostname = extract_hostname(volume_info.UNC);
1961 if (IS_ERR(srvTcp->hostname)) {
1962 rc = PTR_ERR(srvTcp->hostname);
1963 sock_release(csocket);
1966 init_waitqueue_head(&srvTcp->response_q);
1967 init_waitqueue_head(&srvTcp->request_q);
1968 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1969 /* at this point we are the only ones with the pointer
1970 to the struct since the kernel thread not created yet
1971 so no need to spinlock this init of tcpStatus */
1972 srvTcp->tcpStatus = CifsNew;
1973 init_MUTEX(&srvTcp->tcpSem);
1974 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1975 if (IS_ERR(srvTcp->tsk)) {
1976 rc = PTR_ERR(srvTcp->tsk);
1977 cERROR(1, ("error %d create cifsd thread", rc));
1979 sock_release(csocket);
1980 kfree(srvTcp->hostname);
1984 memcpy(srvTcp->workstation_RFC1001_name,
1985 volume_info.source_rfc1001_name, 16);
1986 memcpy(srvTcp->server_RFC1001_name,
1987 volume_info.target_rfc1001_name, 16);
1988 srvTcp->sequence_number = 0;
1992 if (existingCifsSes) {
1993 pSesInfo = existingCifsSes;
1994 cFYI(1, ("Existing smb sess found (status=%d)",
1996 down(&pSesInfo->sesSem);
1997 if (pSesInfo->status == CifsNeedReconnect) {
1998 cFYI(1, ("Session needs reconnect"));
1999 rc = cifs_setup_session(xid, pSesInfo,
2000 cifs_sb->local_nls);
2002 up(&pSesInfo->sesSem);
2004 cFYI(1, ("Existing smb sess not found"));
2005 pSesInfo = sesInfoAlloc();
2006 if (pSesInfo == NULL)
2009 pSesInfo->server = srvTcp;
2010 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2011 NIPQUAD(sin_server.sin_addr.s_addr));
2015 /* volume_info.password freed at unmount */
2016 if (volume_info.password) {
2017 pSesInfo->password = volume_info.password;
2018 /* set to NULL to prevent freeing on exit */
2019 volume_info.password = NULL;
2021 if (volume_info.username)
2022 strncpy(pSesInfo->userName,
2023 volume_info.username,
2025 if (volume_info.domainname) {
2026 int len = strlen(volume_info.domainname);
2027 pSesInfo->domainName =
2028 kmalloc(len + 1, GFP_KERNEL);
2029 if (pSesInfo->domainName)
2030 strcpy(pSesInfo->domainName,
2031 volume_info.domainname);
2033 pSesInfo->linux_uid = volume_info.linux_uid;
2034 pSesInfo->overrideSecFlg = volume_info.secFlg;
2035 down(&pSesInfo->sesSem);
2036 /* BB FIXME need to pass vol->secFlgs BB */
2037 rc = cifs_setup_session(xid, pSesInfo,
2038 cifs_sb->local_nls);
2039 up(&pSesInfo->sesSem);
2041 atomic_inc(&srvTcp->socketUseCount);
2045 /* search for existing tcon to this server share */
2047 if (volume_info.rsize > CIFSMaxBufSize) {
2048 cERROR(1, ("rsize %d too large, using MaxBufSize",
2049 volume_info.rsize));
2050 cifs_sb->rsize = CIFSMaxBufSize;
2051 } else if ((volume_info.rsize) &&
2052 (volume_info.rsize <= CIFSMaxBufSize))
2053 cifs_sb->rsize = volume_info.rsize;
2055 cifs_sb->rsize = CIFSMaxBufSize;
2057 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2058 cERROR(1, ("wsize %d too large, using 4096 instead",
2059 volume_info.wsize));
2060 cifs_sb->wsize = 4096;
2061 } else if (volume_info.wsize)
2062 cifs_sb->wsize = volume_info.wsize;
2065 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2067 /* old default of CIFSMaxBufSize was too small now
2068 that SMB Write2 can send multiple pages in kvec.
2069 RFC1001 does not describe what happens when frame
2070 bigger than 128K is sent so use that as max in
2071 conjunction with 52K kvec constraint on arch with 4K
2074 if (cifs_sb->rsize < 2048) {
2075 cifs_sb->rsize = 2048;
2076 /* Windows ME may prefer this */
2077 cFYI(1, ("readsize set to minimum: 2048"));
2079 /* calculate prepath */
2080 cifs_sb->prepath = volume_info.prepath;
2081 if (cifs_sb->prepath) {
2082 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2083 /* we can not convert the / to \ in the path
2084 separators in the prefixpath yet because we do not
2085 know (until reset_cifs_unix_caps is called later)
2086 whether POSIX PATH CAP is available. We normalize
2087 the / to \ after reset_cifs_unix_caps is called */
2088 volume_info.prepath = NULL;
2090 cifs_sb->prepathlen = 0;
2091 cifs_sb->mnt_uid = volume_info.linux_uid;
2092 cifs_sb->mnt_gid = volume_info.linux_gid;
2093 cifs_sb->mnt_file_mode = volume_info.file_mode;
2094 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2095 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2096 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2098 if (volume_info.noperm)
2099 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2100 if (volume_info.setuids)
2101 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2102 if (volume_info.server_ino)
2103 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2104 if (volume_info.remap)
2105 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2106 if (volume_info.no_xattr)
2107 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2108 if (volume_info.sfu_emul)
2109 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2110 if (volume_info.nobrl)
2111 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2112 if (volume_info.cifs_acl)
2113 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2114 if (volume_info.override_uid)
2115 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2116 if (volume_info.override_gid)
2117 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
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;
2124 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2125 volume_info.username);
2127 cFYI(1, ("Found match on UNC path"));
2128 /* we can have only one retry value for a connection
2129 to a share so for resources mounted more than once
2130 to the same server share the last value passed in
2131 for the retry flag is used */
2132 tcon->retry = volume_info.retry;
2133 tcon->nocase = volume_info.nocase;
2135 tcon = tconInfoAlloc();
2139 /* check for null share name ie connecting to
2142 /* BB check if this works for exactly length
2144 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2145 && (strchr(volume_info.UNC + 3, '/') ==
2147 rc = connect_to_dfs_path(xid, pSesInfo,
2148 "", cifs_sb->local_nls,
2149 cifs_sb->mnt_cifs_flags &
2150 CIFS_MOUNT_MAP_SPECIAL_CHR);
2154 /* BB Do we need to wrap sesSem around
2155 * this TCon call and Unix SetFS as
2156 * we do on SessSetup and reconnect? */
2157 rc = CIFSTCon(xid, pSesInfo,
2159 tcon, cifs_sb->local_nls);
2160 cFYI(1, ("CIFS Tcon rc = %d", rc));
2163 atomic_inc(&pSesInfo->inUse);
2164 tcon->retry = volume_info.retry;
2165 tcon->nocase = volume_info.nocase;
2171 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2172 sb->s_maxbytes = (u64) 1 << 63;
2174 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2177 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2178 sb->s_time_gran = 100;
2180 /* on error free sesinfo and tcon struct if needed */
2182 /* if session setup failed, use count is zero but
2183 we still need to free cifsd thread */
2184 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2185 spin_lock(&GlobalMid_Lock);
2186 srvTcp->tcpStatus = CifsExiting;
2187 spin_unlock(&GlobalMid_Lock);
2189 struct task_struct *tsk;
2190 /* If we could verify that kthread_stop would
2191 always wake up processes blocked in
2192 tcp in recv_mesg then we could remove the
2194 force_sig(SIGKILL, srvTcp->tsk);
2200 /* If find_unc succeeded then rc == 0 so we can not end */
2201 if (tcon) /* up accidently freeing someone elses tcon struct */
2203 if (existingCifsSes == NULL) {
2205 if ((pSesInfo->server) &&
2206 (pSesInfo->status == CifsGood)) {
2208 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2209 /* if the socketUseCount is now zero */
2210 if ((temp_rc == -ESHUTDOWN) &&
2211 (pSesInfo->server) &&
2212 (pSesInfo->server->tsk)) {
2213 struct task_struct *tsk;
2215 pSesInfo->server->tsk);
2216 tsk = pSesInfo->server->tsk;
2221 cFYI(1, ("No session or bad tcon"));
2222 if ((pSesInfo->server) &&
2223 (pSesInfo->server->tsk)) {
2224 struct task_struct *tsk;
2226 pSesInfo->server->tsk);
2227 tsk = 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();
2316 if (smb_buffer == NULL) {
2319 smb_buffer_response = smb_buffer;
2320 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2322 /* send SMBsessionSetup here */
2323 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2324 NULL /* no tCon exists yet */ , 13 /* wct */ );
2326 smb_buffer->Mid = GetNextMid(ses->server);
2327 pSMB->req_no_secext.AndXCommand = 0xFF;
2328 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2329 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2331 if (ses->server->secMode &
2332 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2333 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2335 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2336 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2337 if (ses->capabilities & CAP_UNICODE) {
2338 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2339 capabilities |= CAP_UNICODE;
2341 if (ses->capabilities & CAP_STATUS32) {
2342 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2343 capabilities |= CAP_STATUS32;
2345 if (ses->capabilities & CAP_DFS) {
2346 smb_buffer->Flags2 |= SMBFLG2_DFS;
2347 capabilities |= CAP_DFS;
2349 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2351 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2352 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2354 pSMB->req_no_secext.CaseSensitivePasswordLength =
2355 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2356 bcc_ptr = pByteArea(smb_buffer);
2357 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2358 bcc_ptr += CIFS_SESS_KEY_SIZE;
2359 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2360 bcc_ptr += CIFS_SESS_KEY_SIZE;
2362 if (ses->capabilities & CAP_UNICODE) {
2363 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2368 bytes_returned = 0; /* skip null user */
2371 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2373 /* convert number of 16 bit words to bytes */
2374 bcc_ptr += 2 * bytes_returned;
2375 bcc_ptr += 2; /* trailing null */
2378 cifs_strtoUCS((__le16 *) bcc_ptr,
2379 "CIFS_LINUX_DOM", 32, nls_codepage);
2382 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2384 bcc_ptr += 2 * bytes_returned;
2387 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2389 bcc_ptr += 2 * bytes_returned;
2391 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2393 bcc_ptr += 2 * bytes_returned;
2396 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2398 bcc_ptr += 2 * bytes_returned;
2402 strncpy(bcc_ptr, user, 200);
2403 bcc_ptr += strnlen(user, 200);
2407 if (domain == NULL) {
2408 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2409 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2411 strncpy(bcc_ptr, domain, 64);
2412 bcc_ptr += strnlen(domain, 64);
2416 strcpy(bcc_ptr, "Linux version ");
2417 bcc_ptr += strlen("Linux version ");
2418 strcpy(bcc_ptr, utsname()->release);
2419 bcc_ptr += strlen(utsname()->release) + 1;
2420 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2421 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2423 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2424 smb_buffer->smb_buf_length += count;
2425 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2427 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2428 &bytes_returned, CIFS_LONG_OP);
2430 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2431 } else if ((smb_buffer_response->WordCount == 3)
2432 || (smb_buffer_response->WordCount == 4)) {
2433 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2434 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2435 if (action & GUEST_LOGIN)
2436 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2437 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2439 cFYI(1, ("UID = %d ", ses->Suid));
2440 /* response can have either 3 or 4 word count - Samba sends 3 */
2441 bcc_ptr = pByteArea(smb_buffer_response);
2442 if ((pSMBr->resp.hdr.WordCount == 3)
2443 || ((pSMBr->resp.hdr.WordCount == 4)
2444 && (blob_len < pSMBr->resp.ByteCount))) {
2445 if (pSMBr->resp.hdr.WordCount == 4)
2446 bcc_ptr += blob_len;
2448 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2449 if ((long) (bcc_ptr) % 2) {
2451 (BCC(smb_buffer_response) - 1) / 2;
2452 /* Unicode strings must be word
2457 BCC(smb_buffer_response) / 2;
2460 UniStrnlen((wchar_t *) bcc_ptr,
2461 remaining_words - 1);
2462 /* We look for obvious messed up bcc or strings in response so we do not go off
2463 the end since (at least) WIN2K and Windows XP have a major bug in not null
2464 terminating last Unicode string in response */
2466 kfree(ses->serverOS);
2467 ses->serverOS = kzalloc(2 * (len + 1),
2469 if (ses->serverOS == NULL)
2470 goto sesssetup_nomem;
2471 cifs_strfromUCS_le(ses->serverOS,
2474 bcc_ptr += 2 * (len + 1);
2475 remaining_words -= len + 1;
2476 ses->serverOS[2 * len] = 0;
2477 ses->serverOS[1 + (2 * len)] = 0;
2478 if (remaining_words > 0) {
2479 len = UniStrnlen((wchar_t *)bcc_ptr,
2481 kfree(ses->serverNOS);
2482 ses->serverNOS = kzalloc(2 * (len + 1),
2484 if (ses->serverNOS == NULL)
2485 goto sesssetup_nomem;
2486 cifs_strfromUCS_le(ses->serverNOS,
2489 bcc_ptr += 2 * (len + 1);
2490 ses->serverNOS[2 * len] = 0;
2491 ses->serverNOS[1 + (2 * len)] = 0;
2492 if (strncmp(ses->serverNOS,
2493 "NT LAN Manager 4", 16) == 0) {
2494 cFYI(1, ("NT4 server"));
2495 ses->flags |= CIFS_SES_NT4;
2497 remaining_words -= len + 1;
2498 if (remaining_words > 0) {
2499 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2500 /* last string is not always null terminated
2501 (for e.g. for Windows XP & 2000) */
2502 if (ses->serverDomain)
2503 kfree(ses->serverDomain);
2507 if (ses->serverDomain == NULL)
2508 goto sesssetup_nomem;
2509 cifs_strfromUCS_le(ses->serverDomain,
2512 bcc_ptr += 2 * (len + 1);
2513 ses->serverDomain[2*len] = 0;
2514 ses->serverDomain[1+(2*len)] = 0;
2515 } else { /* else no more room so create
2516 dummy domain string */
2517 if (ses->serverDomain)
2518 kfree(ses->serverDomain);
2520 kzalloc(2, GFP_KERNEL);
2522 } else { /* no room so create dummy domain
2525 /* if these kcallocs fail not much we
2526 can do, but better to not fail the
2528 kfree(ses->serverDomain);
2530 kzalloc(2, GFP_KERNEL);
2531 kfree(ses->serverNOS);
2533 kzalloc(2, GFP_KERNEL);
2535 } else { /* ASCII */
2536 len = strnlen(bcc_ptr, 1024);
2537 if (((long) bcc_ptr + len) - (long)
2538 pByteArea(smb_buffer_response)
2539 <= BCC(smb_buffer_response)) {
2540 kfree(ses->serverOS);
2541 ses->serverOS = kzalloc(len + 1,
2543 if (ses->serverOS == NULL)
2544 goto sesssetup_nomem;
2545 strncpy(ses->serverOS, bcc_ptr, len);
2548 /* null terminate the string */
2552 len = strnlen(bcc_ptr, 1024);
2553 kfree(ses->serverNOS);
2554 ses->serverNOS = kzalloc(len + 1,
2556 if (ses->serverNOS == NULL)
2557 goto sesssetup_nomem;
2558 strncpy(ses->serverNOS, bcc_ptr, len);
2563 len = strnlen(bcc_ptr, 1024);
2564 if (ses->serverDomain)
2565 kfree(ses->serverDomain);
2566 ses->serverDomain = kzalloc(len + 1,
2568 if (ses->serverDomain == NULL)
2569 goto sesssetup_nomem;
2570 strncpy(ses->serverDomain, bcc_ptr,
2577 ("Variable field of length %d "
2578 "extends beyond end of smb ",
2583 (" Security Blob Length extends beyond "
2588 (" Invalid Word count %d: ",
2589 smb_buffer_response->WordCount));
2592 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2593 since that could make reconnection harder, and
2594 reconnection might be needed to free memory */
2595 cifs_buf_release(smb_buffer);
2601 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2602 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2603 const struct nls_table *nls_codepage)
2605 struct smb_hdr *smb_buffer;
2606 struct smb_hdr *smb_buffer_response;
2607 SESSION_SETUP_ANDX *pSMB;
2608 SESSION_SETUP_ANDX *pSMBr;
2612 int remaining_words = 0;
2613 int bytes_returned = 0;
2615 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2616 PNEGOTIATE_MESSAGE SecurityBlob;
2617 PCHALLENGE_MESSAGE SecurityBlob2;
2618 __u32 negotiate_flags, capabilities;
2621 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2624 domain = ses->domainName;
2625 *pNTLMv2_flag = false;
2626 smb_buffer = cifs_buf_get();
2627 if (smb_buffer == NULL) {
2630 smb_buffer_response = smb_buffer;
2631 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2632 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2634 /* send SMBsessionSetup here */
2635 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2636 NULL /* no tCon exists yet */ , 12 /* wct */ );
2638 smb_buffer->Mid = GetNextMid(ses->server);
2639 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2640 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2642 pSMB->req.AndXCommand = 0xFF;
2643 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2644 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2646 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2647 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2649 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2650 CAP_EXTENDED_SECURITY;
2651 if (ses->capabilities & CAP_UNICODE) {
2652 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2653 capabilities |= CAP_UNICODE;
2655 if (ses->capabilities & CAP_STATUS32) {
2656 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2657 capabilities |= CAP_STATUS32;
2659 if (ses->capabilities & CAP_DFS) {
2660 smb_buffer->Flags2 |= SMBFLG2_DFS;
2661 capabilities |= CAP_DFS;
2663 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2665 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2666 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2667 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2668 SecurityBlob->MessageType = NtLmNegotiate;
2670 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2671 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2672 NTLMSSP_NEGOTIATE_56 |
2673 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2675 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2676 /* if (ntlmv2_support)
2677 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2678 /* setup pointers to domain name and workstation name */
2679 bcc_ptr += SecurityBlobLength;
2681 SecurityBlob->WorkstationName.Buffer = 0;
2682 SecurityBlob->WorkstationName.Length = 0;
2683 SecurityBlob->WorkstationName.MaximumLength = 0;
2685 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2686 along with username on auth request (ie the response to challenge) */
2687 SecurityBlob->DomainName.Buffer = 0;
2688 SecurityBlob->DomainName.Length = 0;
2689 SecurityBlob->DomainName.MaximumLength = 0;
2690 if (ses->capabilities & CAP_UNICODE) {
2691 if ((long) bcc_ptr % 2) {
2697 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2699 bcc_ptr += 2 * bytes_returned;
2701 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2703 bcc_ptr += 2 * bytes_returned;
2704 bcc_ptr += 2; /* null terminate Linux version */
2706 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2708 bcc_ptr += 2 * bytes_returned;
2711 bcc_ptr += 2; /* null terminate network opsys string */
2714 bcc_ptr += 2; /* null domain */
2715 } else { /* ASCII */
2716 strcpy(bcc_ptr, "Linux version ");
2717 bcc_ptr += strlen("Linux version ");
2718 strcpy(bcc_ptr, utsname()->release);
2719 bcc_ptr += strlen(utsname()->release) + 1;
2720 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2721 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2722 bcc_ptr++; /* empty domain field */
2725 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2726 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2727 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2728 smb_buffer->smb_buf_length += count;
2729 pSMB->req.ByteCount = cpu_to_le16(count);
2731 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2732 &bytes_returned, CIFS_LONG_OP);
2734 if (smb_buffer_response->Status.CifsError ==
2735 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2739 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2740 } else if ((smb_buffer_response->WordCount == 3)
2741 || (smb_buffer_response->WordCount == 4)) {
2742 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2743 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2745 if (action & GUEST_LOGIN)
2746 cFYI(1, (" Guest login"));
2747 /* Do we want to set anything in SesInfo struct when guest login? */
2749 bcc_ptr = pByteArea(smb_buffer_response);
2750 /* response can have either 3 or 4 word count - Samba sends 3 */
2752 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2753 if (SecurityBlob2->MessageType != NtLmChallenge) {
2755 ("Unexpected NTLMSSP message type received %d",
2756 SecurityBlob2->MessageType));
2758 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2759 cFYI(1, ("UID = %d", ses->Suid));
2760 if ((pSMBr->resp.hdr.WordCount == 3)
2761 || ((pSMBr->resp.hdr.WordCount == 4)
2763 pSMBr->resp.ByteCount))) {
2765 if (pSMBr->resp.hdr.WordCount == 4) {
2766 bcc_ptr += blob_len;
2767 cFYI(1, ("Security Blob Length %d",
2771 cFYI(1, ("NTLMSSP Challenge rcvd"));
2773 memcpy(ses->server->cryptKey,
2774 SecurityBlob2->Challenge,
2775 CIFS_CRYPTO_KEY_SIZE);
2776 if (SecurityBlob2->NegotiateFlags &
2777 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2778 *pNTLMv2_flag = true;
2780 if ((SecurityBlob2->NegotiateFlags &
2781 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2782 || (sign_CIFS_PDUs > 1))
2783 ses->server->secMode |=
2784 SECMODE_SIGN_REQUIRED;
2785 if ((SecurityBlob2->NegotiateFlags &
2786 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2787 ses->server->secMode |=
2788 SECMODE_SIGN_ENABLED;
2790 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2791 if ((long) (bcc_ptr) % 2) {
2793 (BCC(smb_buffer_response)
2795 /* Must word align unicode strings */
2800 (smb_buffer_response) / 2;
2803 UniStrnlen((wchar_t *) bcc_ptr,
2804 remaining_words - 1);
2805 /* We look for obvious messed up bcc or strings in response so we do not go off
2806 the end since (at least) WIN2K and Windows XP have a major bug in not null
2807 terminating last Unicode string in response */
2809 kfree(ses->serverOS);
2811 kzalloc(2 * (len + 1), GFP_KERNEL);
2812 cifs_strfromUCS_le(ses->serverOS,
2816 bcc_ptr += 2 * (len + 1);
2817 remaining_words -= len + 1;
2818 ses->serverOS[2 * len] = 0;
2819 ses->serverOS[1 + (2 * len)] = 0;
2820 if (remaining_words > 0) {
2821 len = UniStrnlen((wchar_t *)
2825 kfree(ses->serverNOS);
2827 kzalloc(2 * (len + 1),
2829 cifs_strfromUCS_le(ses->
2835 bcc_ptr += 2 * (len + 1);
2836 ses->serverNOS[2 * len] = 0;
2839 remaining_words -= len + 1;
2840 if (remaining_words > 0) {
2841 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2842 /* last string not always null terminated
2843 (for e.g. for Windows XP & 2000) */
2844 kfree(ses->serverDomain);
2856 ses->serverDomain[2*len]
2861 } /* else no more room so create dummy domain string */
2863 kfree(ses->serverDomain);
2868 } else { /* no room so create dummy domain and NOS string */
2869 kfree(ses->serverDomain);
2871 kzalloc(2, GFP_KERNEL);
2872 kfree(ses->serverNOS);
2874 kzalloc(2, GFP_KERNEL);
2876 } else { /* ASCII */
2877 len = strnlen(bcc_ptr, 1024);
2878 if (((long) bcc_ptr + len) - (long)
2879 pByteArea(smb_buffer_response)
2880 <= BCC(smb_buffer_response)) {
2882 kfree(ses->serverOS);
2886 strncpy(ses->serverOS,
2890 bcc_ptr[0] = 0; /* null terminate string */
2893 len = strnlen(bcc_ptr, 1024);
2894 kfree(ses->serverNOS);
2898 strncpy(ses->serverNOS, bcc_ptr, len);
2903 len = strnlen(bcc_ptr, 1024);
2904 kfree(ses->serverDomain);
2908 strncpy(ses->serverDomain,
2915 ("field of length %d "
2916 "extends beyond end of smb",
2920 cERROR(1, ("Security Blob Length extends beyond"
2924 cERROR(1, ("No session structure passed in."));
2928 (" Invalid Word count %d:",
2929 smb_buffer_response->WordCount));
2933 cifs_buf_release(smb_buffer);
2938 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2939 char *ntlm_session_key, bool ntlmv2_flag,
2940 const struct nls_table *nls_codepage)
2942 struct smb_hdr *smb_buffer;
2943 struct smb_hdr *smb_buffer_response;
2944 SESSION_SETUP_ANDX *pSMB;
2945 SESSION_SETUP_ANDX *pSMBr;
2950 int remaining_words = 0;
2951 int bytes_returned = 0;
2953 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2954 PAUTHENTICATE_MESSAGE SecurityBlob;
2955 __u32 negotiate_flags, capabilities;
2958 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2961 user = ses->userName;
2962 domain = ses->domainName;
2963 smb_buffer = cifs_buf_get();
2964 if (smb_buffer == NULL) {
2967 smb_buffer_response = smb_buffer;
2968 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2969 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2971 /* send SMBsessionSetup here */
2972 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2973 NULL /* no tCon exists yet */ , 12 /* wct */ );
2975 smb_buffer->Mid = GetNextMid(ses->server);
2976 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2977 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2978 pSMB->req.AndXCommand = 0xFF;
2979 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2980 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2982 pSMB->req.hdr.Uid = ses->Suid;
2984 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2985 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2987 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2988 CAP_EXTENDED_SECURITY;
2989 if (ses->capabilities & CAP_UNICODE) {
2990 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2991 capabilities |= CAP_UNICODE;
2993 if (ses->capabilities & CAP_STATUS32) {
2994 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2995 capabilities |= CAP_STATUS32;
2997 if (ses->capabilities & CAP_DFS) {
2998 smb_buffer->Flags2 |= SMBFLG2_DFS;
2999 capabilities |= CAP_DFS;
3001 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3003 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3004 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3005 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3006 SecurityBlob->MessageType = NtLmAuthenticate;
3007 bcc_ptr += SecurityBlobLength;
3008 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3009 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3010 0x80000000 | NTLMSSP_NEGOTIATE_128;
3012 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3014 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3016 /* setup pointers to domain name and workstation name */
3018 SecurityBlob->WorkstationName.Buffer = 0;
3019 SecurityBlob->WorkstationName.Length = 0;
3020 SecurityBlob->WorkstationName.MaximumLength = 0;
3021 SecurityBlob->SessionKey.Length = 0;
3022 SecurityBlob->SessionKey.MaximumLength = 0;
3023 SecurityBlob->SessionKey.Buffer = 0;
3025 SecurityBlob->LmChallengeResponse.Length = 0;
3026 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3027 SecurityBlob->LmChallengeResponse.Buffer = 0;
3029 SecurityBlob->NtChallengeResponse.Length =
3030 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3031 SecurityBlob->NtChallengeResponse.MaximumLength =
3032 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3033 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3034 SecurityBlob->NtChallengeResponse.Buffer =
3035 cpu_to_le32(SecurityBlobLength);
3036 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3037 bcc_ptr += CIFS_SESS_KEY_SIZE;
3039 if (ses->capabilities & CAP_UNICODE) {
3040 if (domain == NULL) {
3041 SecurityBlob->DomainName.Buffer = 0;
3042 SecurityBlob->DomainName.Length = 0;
3043 SecurityBlob->DomainName.MaximumLength = 0;
3045 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3048 SecurityBlob->DomainName.MaximumLength =
3050 SecurityBlob->DomainName.Buffer =
3051 cpu_to_le32(SecurityBlobLength);
3053 SecurityBlobLength += ln;
3054 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3057 SecurityBlob->UserName.Buffer = 0;
3058 SecurityBlob->UserName.Length = 0;
3059 SecurityBlob->UserName.MaximumLength = 0;
3061 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3064 SecurityBlob->UserName.MaximumLength =
3066 SecurityBlob->UserName.Buffer =
3067 cpu_to_le32(SecurityBlobLength);
3069 SecurityBlobLength += ln;
3070 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3073 /* SecurityBlob->WorkstationName.Length =
3074 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3075 SecurityBlob->WorkstationName.Length *= 2;
3076 SecurityBlob->WorkstationName.MaximumLength =
3077 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3078 SecurityBlob->WorkstationName.Buffer =
3079 cpu_to_le32(SecurityBlobLength);
3080 bcc_ptr += SecurityBlob->WorkstationName.Length;
3081 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3082 SecurityBlob->WorkstationName.Length =
3083 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3085 if ((long) bcc_ptr % 2) {
3090 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3092 bcc_ptr += 2 * bytes_returned;
3094 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3096 bcc_ptr += 2 * bytes_returned;
3097 bcc_ptr += 2; /* null term version string */
3099 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3101 bcc_ptr += 2 * bytes_returned;
3104 bcc_ptr += 2; /* null terminate network opsys string */
3107 bcc_ptr += 2; /* null domain */
3108 } else { /* ASCII */
3109 if (domain == NULL) {
3110 SecurityBlob->DomainName.Buffer = 0;
3111 SecurityBlob->DomainName.Length = 0;
3112 SecurityBlob->DomainName.MaximumLength = 0;
3115 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3116 strncpy(bcc_ptr, domain, 63);
3117 ln = strnlen(domain, 64);
3118 SecurityBlob->DomainName.MaximumLength =
3120 SecurityBlob->DomainName.Buffer =
3121 cpu_to_le32(SecurityBlobLength);
3123 SecurityBlobLength += ln;
3124 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3127 SecurityBlob->UserName.Buffer = 0;
3128 SecurityBlob->UserName.Length = 0;
3129 SecurityBlob->UserName.MaximumLength = 0;
3132 strncpy(bcc_ptr, user, 63);
3133 ln = strnlen(user, 64);
3134 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3135 SecurityBlob->UserName.Buffer =
3136 cpu_to_le32(SecurityBlobLength);
3138 SecurityBlobLength += ln;
3139 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3141 /* BB fill in our workstation name if known BB */
3143 strcpy(bcc_ptr, "Linux version ");
3144 bcc_ptr += strlen("Linux version ");
3145 strcpy(bcc_ptr, utsname()->release);
3146 bcc_ptr += strlen(utsname()->release) + 1;
3147 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3148 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3149 bcc_ptr++; /* null domain */
3152 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3153 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3154 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3155 smb_buffer->smb_buf_length += count;
3156 pSMB->req.ByteCount = cpu_to_le16(count);
3158 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3159 &bytes_returned, CIFS_LONG_OP);
3161 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3162 } else if ((smb_buffer_response->WordCount == 3) ||
3163 (smb_buffer_response->WordCount == 4)) {
3164 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3165 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3166 if (action & GUEST_LOGIN)
3167 cFYI(1, (" Guest login")); /* BB Should we set anything
3168 in SesInfo struct ? */
3169 /* if (SecurityBlob2->MessageType != NtLm??) {
3170 cFYI("Unexpected message type on auth response is %d"));
3175 ("Check challenge UID %d vs auth response UID %d",
3176 ses->Suid, smb_buffer_response->Uid));
3177 /* UID left in wire format */
3178 ses->Suid = smb_buffer_response->Uid;
3179 bcc_ptr = pByteArea(smb_buffer_response);
3180 /* response can have either 3 or 4 word count - Samba sends 3 */
3181 if ((pSMBr->resp.hdr.WordCount == 3)
3182 || ((pSMBr->resp.hdr.WordCount == 4)
3184 pSMBr->resp.ByteCount))) {
3185 if (pSMBr->resp.hdr.WordCount == 4) {
3189 ("Security Blob Length %d ",
3194 ("NTLMSSP response to Authenticate "));
3196 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3197 if ((long) (bcc_ptr) % 2) {
3199 (BCC(smb_buffer_response)
3201 bcc_ptr++; /* Unicode strings must be word aligned */
3203 remaining_words = BCC(smb_buffer_response) / 2;
3205 len = UniStrnlen((wchar_t *) bcc_ptr,
3206 remaining_words - 1);
3207 /* We look for obvious messed up bcc or strings in response so we do not go off
3208 the end since (at least) WIN2K and Windows XP have a major bug in not null
3209 terminating last Unicode string in response */
3211 kfree(ses->serverOS);
3213 kzalloc(2 * (len + 1), GFP_KERNEL);
3214 cifs_strfromUCS_le(ses->serverOS,
3218 bcc_ptr += 2 * (len + 1);
3219 remaining_words -= len + 1;
3220 ses->serverOS[2 * len] = 0;
3221 ses->serverOS[1 + (2 * len)] = 0;
3222 if (remaining_words > 0) {
3223 len = UniStrnlen((wchar_t *)
3227 kfree(ses->serverNOS);
3229 kzalloc(2 * (len + 1),
3231 cifs_strfromUCS_le(ses->
3237 bcc_ptr += 2 * (len + 1);
3238 ses->serverNOS[2 * len] = 0;
3239 ses->serverNOS[1+(2*len)] = 0;
3240 remaining_words -= len + 1;
3241 if (remaining_words > 0) {
3242 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3243 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3244 if (ses->serverDomain)
3245 kfree(ses->serverDomain);
3270 } /* else no more room so create dummy domain string */
3272 if (ses->serverDomain)
3273 kfree(ses->serverDomain);
3274 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3276 } else { /* no room so create dummy domain and NOS string */
3277 if (ses->serverDomain)
3278 kfree(ses->serverDomain);
3279 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3280 kfree(ses->serverNOS);
3281 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3283 } else { /* ASCII */
3284 len = strnlen(bcc_ptr, 1024);
3285 if (((long) bcc_ptr + len) -
3286 (long) pByteArea(smb_buffer_response)
3287 <= BCC(smb_buffer_response)) {
3289 kfree(ses->serverOS);
3290 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3291 strncpy(ses->serverOS,bcc_ptr, len);
3294 bcc_ptr[0] = 0; /* null terminate the string */
3297 len = strnlen(bcc_ptr, 1024);
3298 kfree(ses->serverNOS);
3299 ses->serverNOS = kzalloc(len+1,
3301 strncpy(ses->serverNOS,
3307 len = strnlen(bcc_ptr, 1024);
3308 if (ses->serverDomain)
3309 kfree(ses->serverDomain);
3313 strncpy(ses->serverDomain,
3319 cFYI(1, ("field of length %d "
3320 "extends beyond end of smb ",
3324 cERROR(1, ("Security Blob extends beyond end "
3328 cERROR(1, ("No session structure passed in."));
3331 cERROR(1, ("Invalid Word count %d: ",
3332 smb_buffer_response->WordCount));
3336 cifs_buf_release(smb_buffer);
3342 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3343 const char *tree, struct cifsTconInfo *tcon,
3344 const struct nls_table *nls_codepage)
3346 struct smb_hdr *smb_buffer;
3347 struct smb_hdr *smb_buffer_response;
3350 unsigned char *bcc_ptr;
3358 smb_buffer = cifs_buf_get();
3359 if (smb_buffer == NULL) {
3362 smb_buffer_response = smb_buffer;
3364 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3365 NULL /*no tid */ , 4 /*wct */ );
3367 smb_buffer->Mid = GetNextMid(ses->server);
3368 smb_buffer->Uid = ses->Suid;
3369 pSMB = (TCONX_REQ *) smb_buffer;
3370 pSMBr = (TCONX_RSP *) smb_buffer_response;
3372 pSMB->AndXCommand = 0xFF;
3373 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3374 bcc_ptr = &pSMB->Password[0];
3375 if ((ses->server->secMode) & SECMODE_USER) {
3376 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3377 *bcc_ptr = 0; /* password is null byte */
3378 bcc_ptr++; /* skip password */
3379 /* already aligned so no need to do it below */
3381 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3382 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3383 specified as required (when that support is added to
3384 the vfs in the future) as only NTLM or the much
3385 weaker LANMAN (which we do not send by default) is accepted
3386 by Samba (not sure whether other servers allow
3387 NTLMv2 password here) */
3388 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3389 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3390 (ses->server->secType == LANMAN))
3391 calc_lanman_hash(ses, bcc_ptr);
3393 #endif /* CIFS_WEAK_PW_HASH */
3394 SMBNTencrypt(ses->password,
3395 ses->server->cryptKey,
3398 bcc_ptr += CIFS_SESS_KEY_SIZE;
3399 if (ses->capabilities & CAP_UNICODE) {
3400 /* must align unicode strings */
3401 *bcc_ptr = 0; /* null byte password */
3406 if (ses->server->secMode &
3407 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3408 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3410 if (ses->capabilities & CAP_STATUS32) {
3411 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3413 if (ses->capabilities & CAP_DFS) {
3414 smb_buffer->Flags2 |= SMBFLG2_DFS;
3416 if (ses->capabilities & CAP_UNICODE) {
3417 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3419 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3420 6 /* max utf8 char length in bytes */ *
3421 (/* server len*/ + 256 /* share len */), nls_codepage);
3422 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3423 bcc_ptr += 2; /* skip trailing null */
3424 } else { /* ASCII */
3425 strcpy(bcc_ptr, tree);
3426 bcc_ptr += strlen(tree) + 1;
3428 strcpy(bcc_ptr, "?????");
3429 bcc_ptr += strlen("?????");
3431 count = bcc_ptr - &pSMB->Password[0];
3432 pSMB->hdr.smb_buf_length += count;
3433 pSMB->ByteCount = cpu_to_le16(count);
3435 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3438 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3439 /* above now done in SendReceive */
3440 if ((rc == 0) && (tcon != NULL)) {
3441 tcon->tidStatus = CifsGood;
3442 tcon->tid = smb_buffer_response->Tid;
3443 bcc_ptr = pByteArea(smb_buffer_response);
3444 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3445 /* skip service field (NB: this field is always ASCII) */
3447 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3448 (bcc_ptr[2] == 'C')) {
3449 cFYI(1, ("IPC connection"));
3452 } else if (length == 2) {
3453 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3454 /* the most common case */
3455 cFYI(1, ("disk share connection"));
3458 bcc_ptr += length + 1;
3459 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3460 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3461 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3462 if ((bcc_ptr + (2 * length)) -
3463 pByteArea(smb_buffer_response) <=
3464 BCC(smb_buffer_response)) {
3465 kfree(tcon->nativeFileSystem);
3466 tcon->nativeFileSystem =
3467 kzalloc(length + 2, GFP_KERNEL);
3468 if (tcon->nativeFileSystem)
3470 tcon->nativeFileSystem,
3472 length, nls_codepage);
3473 bcc_ptr += 2 * length;
3474 bcc_ptr[0] = 0; /* null terminate the string */
3478 /* else do not bother copying these information fields*/
3480 length = strnlen(bcc_ptr, 1024);
3481 if ((bcc_ptr + length) -
3482 pByteArea(smb_buffer_response) <=
3483 BCC(smb_buffer_response)) {
3484 kfree(tcon->nativeFileSystem);
3485 tcon->nativeFileSystem =
3486 kzalloc(length + 1, GFP_KERNEL);
3487 if (tcon->nativeFileSystem)
3488 strncpy(tcon->nativeFileSystem, bcc_ptr,
3491 /* else do not bother copying these information fields*/
3493 if ((smb_buffer_response->WordCount == 3) ||
3494 (smb_buffer_response->WordCount == 7))
3495 /* field is in same location */
3496 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3499 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3500 } else if ((rc == 0) && tcon == NULL) {
3501 /* all we need to save for IPC$ connection */
3502 ses->ipc_tid = smb_buffer_response->Tid;
3505 cifs_buf_release(smb_buffer);
3510 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3514 struct cifsSesInfo *ses = NULL;
3515 struct task_struct *cifsd_task;
3520 if (cifs_sb->tcon) {
3521 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3522 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3527 DeleteTconOplockQEntries(cifs_sb->tcon);
3528 tconInfoFree(cifs_sb->tcon);
3529 if ((ses) && (ses->server)) {
3530 /* save off task so we do not refer to ses later */
3531 cifsd_task = ses->server->tsk;
3532 cFYI(1, ("About to do SMBLogoff "));
3533 rc = CIFSSMBLogoff(xid, ses);
3537 } else if (rc == -ESHUTDOWN) {
3538 cFYI(1, ("Waking up socket by sending signal"));
3540 force_sig(SIGKILL, cifsd_task);
3541 kthread_stop(cifsd_task);
3544 } /* else - we have an smb session
3545 left on this socket do not kill cifsd */
3547 cFYI(1, ("No session or bad tcon"));
3550 cifs_sb->tcon = NULL;
3551 tmp = cifs_sb->prepath;
3552 cifs_sb->prepathlen = 0;
3553 cifs_sb->prepath = NULL;
3562 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3563 struct nls_table *nls_info)
3566 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3567 bool ntlmv2_flag = false;
3570 /* what if server changes its buffer size after dropping the session? */
3571 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3572 rc = CIFSSMBNegotiate(xid, pSesInfo);
3573 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3574 rc = CIFSSMBNegotiate(xid, pSesInfo);
3579 spin_lock(&GlobalMid_Lock);
3580 if (pSesInfo->server->tcpStatus != CifsExiting)
3581 pSesInfo->server->tcpStatus = CifsGood;
3584 spin_unlock(&GlobalMid_Lock);
3590 pSesInfo->flags = 0;
3591 pSesInfo->capabilities = pSesInfo->server->capabilities;
3592 if (linuxExtEnabled == 0)
3593 pSesInfo->capabilities &= (~CAP_UNIX);
3594 /* pSesInfo->sequence_number = 0;*/
3596 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3597 pSesInfo->server->secMode,
3598 pSesInfo->server->capabilities,
3599 pSesInfo->server->timeAdj));
3600 if (experimEnabled < 2)
3601 rc = CIFS_SessSetup(xid, pSesInfo,
3602 first_time, nls_info);
3603 else if (extended_security
3604 && (pSesInfo->capabilities
3605 & CAP_EXTENDED_SECURITY)
3606 && (pSesInfo->server->secType == NTLMSSP)) {
3608 } else if (extended_security
3609 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3610 && (pSesInfo->server->secType == RawNTLMSSP)) {
3611 cFYI(1, ("NTLMSSP sesssetup"));
3612 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3619 cFYI(1, ("more secure NTLM ver2 hash"));
3620 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3625 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3627 CalcNTLMv2_response(pSesInfo,
3630 cifs_calculate_ntlmv2_mac_key(
3631 pSesInfo->server->mac_signing_key,
3632 response, ntlm_session_key,*/
3634 /* BB Put dummy sig in SessSetup PDU? */
3641 SMBNTencrypt(pSesInfo->password,
3642 pSesInfo->server->cryptKey,
3646 cifs_calculate_mac_key(
3647 &pSesInfo->server->mac_signing_key,
3649 pSesInfo->password);
3651 /* for better security the weaker lanman hash not sent
3652 in AuthSessSetup so we no longer calculate it */
3654 rc = CIFSNTLMSSPAuthSessSetup(xid,
3660 } else { /* old style NTLM 0.12 session setup */
3661 SMBNTencrypt(pSesInfo->password,
3662 pSesInfo->server->cryptKey,
3666 cifs_calculate_mac_key(
3667 &pSesInfo->server->mac_signing_key,
3668 ntlm_session_key, pSesInfo->password);
3670 rc = CIFSSessSetup(xid, pSesInfo,
3671 ntlm_session_key, nls_info);
3674 cERROR(1, ("Send error in SessSetup = %d", rc));
3676 cFYI(1, ("CIFS Session Established successfully"));
3677 pSesInfo->status = CifsGood;