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");
1306 printk(KERN_WARNING "CIFS: UNC name too long\n");
1310 if (vol->UNCip == NULL)
1311 vol->UNCip = &vol->UNC[2];
1316 static struct cifsSesInfo *
1317 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1318 struct in6_addr *target_ip6_addr,
1319 char *userName, struct TCP_Server_Info **psrvTcp)
1321 struct list_head *tmp;
1322 struct cifsSesInfo *ses;
1324 read_lock(&GlobalSMBSeslock);
1326 list_for_each(tmp, &GlobalSMBSessionList) {
1327 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1329 if ((target_ip_addr &&
1330 (ses->server->addr.sockAddr.sin_addr.s_addr
1331 == target_ip_addr->s_addr)) || (target_ip6_addr
1332 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1333 target_ip6_addr, sizeof(*target_ip6_addr)))) {
1334 /* BB lock server and tcp session and increment
1337 /* found a match on the TCP session */
1338 *psrvTcp = ses->server;
1340 /* BB check if reconnection needed */
1342 (ses->userName, userName,
1343 MAX_USERNAME_SIZE) == 0){
1344 read_unlock(&GlobalSMBSeslock);
1345 /* Found exact match on both TCP and
1351 /* else tcp and smb sessions need reconnection */
1353 read_unlock(&GlobalSMBSeslock);
1357 static struct cifsTconInfo *
1358 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1360 struct list_head *tmp;
1361 struct cifsTconInfo *tcon;
1364 read_lock(&GlobalSMBSeslock);
1366 list_for_each(tmp, &GlobalTreeConnectionList) {
1367 cFYI(1, ("Next tcon"));
1368 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1369 if (!tcon->ses || !tcon->ses->server)
1372 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1373 cFYI(1, ("old ip addr: %x == new ip %x ?",
1374 old_ip, new_target_ip_addr));
1376 if (old_ip != new_target_ip_addr)
1379 /* BB lock tcon, server, tcp session and increment use count? */
1380 /* found a match on the TCP session */
1381 /* BB check if reconnection needed */
1382 cFYI(1, ("IP match, old UNC: %s new: %s",
1383 tcon->treeName, uncName));
1385 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1388 cFYI(1, ("and old usr: %s new: %s",
1389 tcon->treeName, uncName));
1391 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1394 /* matched smb session (user name) */
1395 read_unlock(&GlobalSMBSeslock);
1399 read_unlock(&GlobalSMBSeslock);
1404 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1405 const char *old_path, const struct nls_table *nls_codepage,
1408 struct dfs_info3_param *referrals = NULL;
1409 unsigned int num_referrals;
1412 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
1413 &num_referrals, &referrals, remap);
1415 /* BB Add in code to: if valid refrl, if not ip address contact
1416 the helper that resolves tcp names, mount to it, try to
1417 tcon to it unmount it if fail */
1425 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1426 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1427 struct dfs_info3_param **preferrals, int remap)
1431 unsigned char *targetUNCs;
1433 *pnum_referrals = 0;
1436 if (pSesInfo->ipc_tid == 0) {
1437 temp_unc = kmalloc(2 /* for slashes */ +
1438 strnlen(pSesInfo->serverName,
1439 SERVER_NAME_LEN_WITH_NULL * 2)
1440 + 1 + 4 /* slash IPC$ */ + 2,
1442 if (temp_unc == NULL)
1446 strcpy(temp_unc + 2, pSesInfo->serverName);
1447 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1448 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1450 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1454 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
1455 pnum_referrals, nls_codepage, remap);
1456 /* BB map targetUNCs to dfs_info3 structures, here or
1457 in CIFSGetDFSRefer BB */
1462 /* See RFC1001 section 14 on representation of Netbios names */
1463 static void rfc1002mangle(char *target, char *source, unsigned int length)
1467 for (i = 0, j = 0; i < (length); i++) {
1468 /* mask a nibble at a time and encode */
1469 target[j] = 'A' + (0x0F & (source[i] >> 4));
1470 target[j+1] = 'A' + (0x0F & source[i]);
1478 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1479 char *netbios_name, char *target_name)
1483 __be16 orig_port = 0;
1485 if (*csocket == NULL) {
1486 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1487 IPPROTO_TCP, csocket);
1489 cERROR(1, ("Error %d creating socket", rc));
1493 /* BB other socket options to set KEEPALIVE, NODELAY? */
1494 cFYI(1, ("Socket created"));
1495 (*csocket)->sk->sk_allocation = GFP_NOFS;
1499 psin_server->sin_family = AF_INET;
1500 if (psin_server->sin_port) { /* user overrode default port */
1501 rc = (*csocket)->ops->connect(*csocket,
1502 (struct sockaddr *) psin_server,
1503 sizeof(struct sockaddr_in), 0);
1509 /* save original port so we can retry user specified port
1510 later if fall back ports fail this time */
1511 orig_port = psin_server->sin_port;
1513 /* do not retry on the same port we just failed on */
1514 if (psin_server->sin_port != htons(CIFS_PORT)) {
1515 psin_server->sin_port = htons(CIFS_PORT);
1517 rc = (*csocket)->ops->connect(*csocket,
1518 (struct sockaddr *) psin_server,
1519 sizeof(struct sockaddr_in), 0);
1525 psin_server->sin_port = htons(RFC1001_PORT);
1526 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1528 sizeof(struct sockaddr_in), 0);
1533 /* give up here - unless we want to retry on different
1534 protocol families some day */
1537 psin_server->sin_port = orig_port;
1538 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1539 sock_release(*csocket);
1543 /* Eventually check for other socket options to change from
1544 the default. sock_setsockopt not used because it expects
1545 user space buffer */
1546 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1547 (*csocket)->sk->sk_sndbuf,
1548 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1549 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1550 /* make the bufsizes depend on wsize/rsize and max requests */
1551 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1552 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1553 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1554 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1556 /* send RFC1001 sessinit */
1557 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1558 /* some servers require RFC1001 sessinit before sending
1559 negprot - BB check reconnection in case where second
1560 sessinit is sent but no second negprot */
1561 struct rfc1002_session_packet *ses_init_buf;
1562 struct smb_hdr *smb_buf;
1563 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1566 ses_init_buf->trailer.session_req.called_len = 32;
1567 if (target_name && (target_name[0] != 0)) {
1568 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1571 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1572 DEFAULT_CIFS_CALLED_NAME, 16);
1575 ses_init_buf->trailer.session_req.calling_len = 32;
1576 /* calling name ends in null (byte 16) from old smb
1578 if (netbios_name && (netbios_name[0] != 0)) {
1579 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1582 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1583 "LINUX_CIFS_CLNT", 16);
1585 ses_init_buf->trailer.session_req.scope1 = 0;
1586 ses_init_buf->trailer.session_req.scope2 = 0;
1587 smb_buf = (struct smb_hdr *)ses_init_buf;
1588 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1589 smb_buf->smb_buf_length = 0x81000044;
1590 rc = smb_send(*csocket, smb_buf, 0x44,
1591 (struct sockaddr *)psin_server);
1592 kfree(ses_init_buf);
1593 msleep(1); /* RFC1001 layer in at least one server
1594 requires very short break before negprot
1595 presumably because not expecting negprot
1596 to follow so fast. This is a simple
1597 solution that works without
1598 complicating the code and causes no
1599 significant slowing down on mount
1600 for everyone else */
1602 /* else the negprot may still work without this
1603 even though malloc failed */
1611 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1615 __be16 orig_port = 0;
1617 if (*csocket == NULL) {
1618 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1619 IPPROTO_TCP, csocket);
1621 cERROR(1, ("Error %d creating ipv6 socket", rc));
1625 /* BB other socket options to set KEEPALIVE, NODELAY? */
1626 cFYI(1, ("ipv6 Socket created"));
1627 (*csocket)->sk->sk_allocation = GFP_NOFS;
1631 psin_server->sin6_family = AF_INET6;
1633 if (psin_server->sin6_port) { /* user overrode default port */
1634 rc = (*csocket)->ops->connect(*csocket,
1635 (struct sockaddr *) psin_server,
1636 sizeof(struct sockaddr_in6), 0);
1642 /* save original port so we can retry user specified port
1643 later if fall back ports fail this time */
1645 orig_port = psin_server->sin6_port;
1646 /* do not retry on the same port we just failed on */
1647 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1648 psin_server->sin6_port = htons(CIFS_PORT);
1650 rc = (*csocket)->ops->connect(*csocket,
1651 (struct sockaddr *) psin_server,
1652 sizeof(struct sockaddr_in6), 0);
1658 psin_server->sin6_port = htons(RFC1001_PORT);
1659 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1660 psin_server, sizeof(struct sockaddr_in6), 0);
1665 /* give up here - unless we want to retry on different
1666 protocol families some day */
1669 psin_server->sin6_port = orig_port;
1670 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1671 sock_release(*csocket);
1675 /* Eventually check for other socket options to change from
1676 the default. sock_setsockopt not used because it expects
1677 user space buffer */
1678 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1683 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1684 struct super_block *sb, struct smb_vol *vol_info)
1686 /* if we are reconnecting then should we check to see if
1687 * any requested capabilities changed locally e.g. via
1688 * remount but we can not do much about it here
1689 * if they have (even if we could detect it by the following)
1690 * Perhaps we could add a backpointer to array of sb from tcon
1691 * or if we change to make all sb to same share the same
1692 * sb as NFS - then we only have one backpointer to sb.
1693 * What if we wanted to mount the server share twice once with
1694 * and once without posixacls or posix paths? */
1695 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1697 if (vol_info && vol_info->no_linux_ext) {
1698 tcon->fsUnixInfo.Capability = 0;
1699 tcon->unix_ext = 0; /* Unix Extensions disabled */
1700 cFYI(1, ("Linux protocol extensions disabled"));
1702 } else if (vol_info)
1703 tcon->unix_ext = 1; /* Unix Extensions supported */
1705 if (tcon->unix_ext == 0) {
1706 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1710 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1711 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1713 /* check for reconnect case in which we do not
1714 want to change the mount behavior if we can avoid it */
1715 if (vol_info == NULL) {
1716 /* turn off POSIX ACL and PATHNAMES if not set
1717 originally at mount time */
1718 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1719 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1720 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1721 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1722 cERROR(1, ("POSIXPATH support change"));
1723 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1724 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1725 cERROR(1, ("possible reconnect error"));
1727 ("server disabled POSIX path support"));
1731 cap &= CIFS_UNIX_CAP_MASK;
1732 if (vol_info && vol_info->no_psx_acl)
1733 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1734 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1735 cFYI(1, ("negotiated posix acl support"));
1737 sb->s_flags |= MS_POSIXACL;
1740 if (vol_info && vol_info->posix_paths == 0)
1741 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1742 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1743 cFYI(1, ("negotiate posix pathnames"));
1745 CIFS_SB(sb)->mnt_cifs_flags |=
1746 CIFS_MOUNT_POSIX_PATHS;
1749 /* We might be setting the path sep back to a different
1750 form if we are reconnecting and the server switched its
1751 posix path capability for this share */
1752 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1753 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1755 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1756 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1757 CIFS_SB(sb)->rsize = 127 * 1024;
1759 ("larger reads not supported by srv"));
1764 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1765 #ifdef CONFIG_CIFS_DEBUG2
1766 if (cap & CIFS_UNIX_FCNTL_CAP)
1767 cFYI(1, ("FCNTL cap"));
1768 if (cap & CIFS_UNIX_EXTATTR_CAP)
1769 cFYI(1, ("EXTATTR cap"));
1770 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1771 cFYI(1, ("POSIX path cap"));
1772 if (cap & CIFS_UNIX_XATTR_CAP)
1773 cFYI(1, ("XATTR cap"));
1774 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1775 cFYI(1, ("POSIX ACL cap"));
1776 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1777 cFYI(1, ("very large read cap"));
1778 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1779 cFYI(1, ("very large write cap"));
1780 #endif /* CIFS_DEBUG2 */
1781 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1782 if (vol_info == NULL) {
1783 cFYI(1, ("resetting capabilities failed"));
1785 cERROR(1, ("Negotiating Unix capabilities "
1786 "with the server failed. Consider "
1787 "mounting with the Unix Extensions\n"
1788 "disabled, if problems are found, "
1789 "by specifying the nounix mount "
1797 convert_delimiter(char *path, char delim)
1810 for (i = 0; path[i] != '\0'; i++) {
1811 if (path[i] == old_delim)
1817 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1818 char *mount_data, const char *devname)
1822 int address_type = AF_INET;
1823 struct socket *csocket = NULL;
1824 struct sockaddr_in sin_server;
1825 struct sockaddr_in6 sin_server6;
1826 struct smb_vol volume_info;
1827 struct cifsSesInfo *pSesInfo = NULL;
1828 struct cifsSesInfo *existingCifsSes = NULL;
1829 struct cifsTconInfo *tcon = NULL;
1830 struct TCP_Server_Info *srvTcp = NULL;
1834 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1836 memset(&volume_info, 0, sizeof(struct smb_vol));
1837 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1842 if (volume_info.nullauth) {
1843 cFYI(1, ("null user"));
1844 volume_info.username = "";
1845 } else if (volume_info.username) {
1846 /* BB fixme parse for domain name here */
1847 cFYI(1, ("Username: %s", volume_info.username));
1849 cifserror("No username specified");
1850 /* In userspace mount helper we can get user name from alternate
1851 locations such as env variables and files on disk */
1856 if (volume_info.UNCip && volume_info.UNC) {
1857 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1858 &sin_server.sin_addr.s_addr);
1861 /* not ipv4 address, try ipv6 */
1862 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1863 &sin_server6.sin6_addr.in6_u);
1865 address_type = AF_INET6;
1867 address_type = AF_INET;
1871 /* we failed translating address */
1876 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1879 } else if (volume_info.UNCip) {
1880 /* BB using ip addr as server name to connect to the
1882 cERROR(1, ("Connecting to DFS root not implemented yet"));
1885 } else /* which servers DFS root would we conect to */ {
1887 ("CIFS mount error: No UNC path (e.g. -o "
1888 "unc=//192.168.1.100/public) specified"));
1893 /* this is needed for ASCII cp to Unicode converts */
1894 if (volume_info.iocharset == NULL) {
1895 cifs_sb->local_nls = load_nls_default();
1896 /* load_nls_default can not return null */
1898 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1899 if (cifs_sb->local_nls == NULL) {
1900 cERROR(1, ("CIFS mount error: iocharset %s not found",
1901 volume_info.iocharset));
1907 if (address_type == AF_INET)
1908 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1909 NULL /* no ipv6 addr */,
1910 volume_info.username, &srvTcp);
1911 else if (address_type == AF_INET6) {
1912 cFYI(1, ("looking for ipv6 address"));
1913 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1914 &sin_server6.sin6_addr,
1915 volume_info.username, &srvTcp);
1922 cFYI(1, ("Existing tcp session with server found"));
1923 } else { /* create socket */
1924 if (volume_info.port)
1925 sin_server.sin_port = htons(volume_info.port);
1927 sin_server.sin_port = 0;
1928 if (address_type == AF_INET6) {
1929 cFYI(1, ("attempting ipv6 connect"));
1930 /* BB should we allow ipv6 on port 139? */
1931 /* other OS never observed in Wild doing 139 with v6 */
1932 rc = ipv6_connect(&sin_server6, &csocket);
1934 rc = ipv4_connect(&sin_server, &csocket,
1935 volume_info.source_rfc1001_name,
1936 volume_info.target_rfc1001_name);
1938 cERROR(1, ("Error connecting to IPv4 socket. "
1939 "Aborting operation"));
1940 if (csocket != NULL)
1941 sock_release(csocket);
1945 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1948 sock_release(csocket);
1951 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1952 sizeof(struct sockaddr_in));
1953 atomic_set(&srvTcp->inFlight, 0);
1954 /* BB Add code for ipv6 case too */
1955 srvTcp->ssocket = csocket;
1956 srvTcp->protocolType = IPV4;
1957 srvTcp->hostname = extract_hostname(volume_info.UNC);
1958 if (IS_ERR(srvTcp->hostname)) {
1959 rc = PTR_ERR(srvTcp->hostname);
1960 sock_release(csocket);
1963 init_waitqueue_head(&srvTcp->response_q);
1964 init_waitqueue_head(&srvTcp->request_q);
1965 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1966 /* at this point we are the only ones with the pointer
1967 to the struct since the kernel thread not created yet
1968 so no need to spinlock this init of tcpStatus */
1969 srvTcp->tcpStatus = CifsNew;
1970 init_MUTEX(&srvTcp->tcpSem);
1971 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1972 if (IS_ERR(srvTcp->tsk)) {
1973 rc = PTR_ERR(srvTcp->tsk);
1974 cERROR(1, ("error %d create cifsd thread", rc));
1976 sock_release(csocket);
1977 kfree(srvTcp->hostname);
1981 memcpy(srvTcp->workstation_RFC1001_name,
1982 volume_info.source_rfc1001_name, 16);
1983 memcpy(srvTcp->server_RFC1001_name,
1984 volume_info.target_rfc1001_name, 16);
1985 srvTcp->sequence_number = 0;
1989 if (existingCifsSes) {
1990 pSesInfo = existingCifsSes;
1991 cFYI(1, ("Existing smb sess found (status=%d)",
1993 down(&pSesInfo->sesSem);
1994 if (pSesInfo->status == CifsNeedReconnect) {
1995 cFYI(1, ("Session needs reconnect"));
1996 rc = cifs_setup_session(xid, pSesInfo,
1997 cifs_sb->local_nls);
1999 up(&pSesInfo->sesSem);
2001 cFYI(1, ("Existing smb sess not found"));
2002 pSesInfo = sesInfoAlloc();
2003 if (pSesInfo == NULL)
2006 pSesInfo->server = srvTcp;
2007 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2008 NIPQUAD(sin_server.sin_addr.s_addr));
2012 /* volume_info.password freed at unmount */
2013 if (volume_info.password) {
2014 pSesInfo->password = volume_info.password;
2015 /* set to NULL to prevent freeing on exit */
2016 volume_info.password = NULL;
2018 if (volume_info.username)
2019 strncpy(pSesInfo->userName,
2020 volume_info.username,
2022 if (volume_info.domainname) {
2023 int len = strlen(volume_info.domainname);
2024 pSesInfo->domainName =
2025 kmalloc(len + 1, GFP_KERNEL);
2026 if (pSesInfo->domainName)
2027 strcpy(pSesInfo->domainName,
2028 volume_info.domainname);
2030 pSesInfo->linux_uid = volume_info.linux_uid;
2031 pSesInfo->overrideSecFlg = volume_info.secFlg;
2032 down(&pSesInfo->sesSem);
2033 /* BB FIXME need to pass vol->secFlgs BB */
2034 rc = cifs_setup_session(xid, pSesInfo,
2035 cifs_sb->local_nls);
2036 up(&pSesInfo->sesSem);
2038 atomic_inc(&srvTcp->socketUseCount);
2042 /* search for existing tcon to this server share */
2044 if (volume_info.rsize > CIFSMaxBufSize) {
2045 cERROR(1, ("rsize %d too large, using MaxBufSize",
2046 volume_info.rsize));
2047 cifs_sb->rsize = CIFSMaxBufSize;
2048 } else if ((volume_info.rsize) &&
2049 (volume_info.rsize <= CIFSMaxBufSize))
2050 cifs_sb->rsize = volume_info.rsize;
2052 cifs_sb->rsize = CIFSMaxBufSize;
2054 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2055 cERROR(1, ("wsize %d too large, using 4096 instead",
2056 volume_info.wsize));
2057 cifs_sb->wsize = 4096;
2058 } else if (volume_info.wsize)
2059 cifs_sb->wsize = volume_info.wsize;
2062 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2064 /* old default of CIFSMaxBufSize was too small now
2065 that SMB Write2 can send multiple pages in kvec.
2066 RFC1001 does not describe what happens when frame
2067 bigger than 128K is sent so use that as max in
2068 conjunction with 52K kvec constraint on arch with 4K
2071 if (cifs_sb->rsize < 2048) {
2072 cifs_sb->rsize = 2048;
2073 /* Windows ME may prefer this */
2074 cFYI(1, ("readsize set to minimum: 2048"));
2076 /* calculate prepath */
2077 cifs_sb->prepath = volume_info.prepath;
2078 if (cifs_sb->prepath) {
2079 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2080 /* we can not convert the / to \ in the path
2081 separators in the prefixpath yet because we do not
2082 know (until reset_cifs_unix_caps is called later)
2083 whether POSIX PATH CAP is available. We normalize
2084 the / to \ after reset_cifs_unix_caps is called */
2085 volume_info.prepath = NULL;
2087 cifs_sb->prepathlen = 0;
2088 cifs_sb->mnt_uid = volume_info.linux_uid;
2089 cifs_sb->mnt_gid = volume_info.linux_gid;
2090 cifs_sb->mnt_file_mode = volume_info.file_mode;
2091 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2092 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2093 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2095 if (volume_info.noperm)
2096 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2097 if (volume_info.setuids)
2098 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2099 if (volume_info.server_ino)
2100 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2101 if (volume_info.remap)
2102 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2103 if (volume_info.no_xattr)
2104 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2105 if (volume_info.sfu_emul)
2106 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2107 if (volume_info.nobrl)
2108 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2109 if (volume_info.cifs_acl)
2110 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2111 if (volume_info.override_uid)
2112 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2113 if (volume_info.override_gid)
2114 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2115 if (volume_info.direct_io) {
2116 cFYI(1, ("mounting share using direct i/o"));
2117 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2121 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2122 volume_info.username);
2124 cFYI(1, ("Found match on UNC path"));
2125 /* we can have only one retry value for a connection
2126 to a share so for resources mounted more than once
2127 to the same server share the last value passed in
2128 for the retry flag is used */
2129 tcon->retry = volume_info.retry;
2130 tcon->nocase = volume_info.nocase;
2132 tcon = tconInfoAlloc();
2136 /* check for null share name ie connecting to
2139 /* BB check if this works for exactly length
2141 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2142 && (strchr(volume_info.UNC + 3, '/') ==
2144 rc = connect_to_dfs_path(xid, pSesInfo,
2145 "", cifs_sb->local_nls,
2146 cifs_sb->mnt_cifs_flags &
2147 CIFS_MOUNT_MAP_SPECIAL_CHR);
2151 /* BB Do we need to wrap sesSem around
2152 * this TCon call and Unix SetFS as
2153 * we do on SessSetup and reconnect? */
2154 rc = CIFSTCon(xid, pSesInfo,
2156 tcon, cifs_sb->local_nls);
2157 cFYI(1, ("CIFS Tcon rc = %d", rc));
2160 atomic_inc(&pSesInfo->inUse);
2161 tcon->retry = volume_info.retry;
2162 tcon->nocase = volume_info.nocase;
2168 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2169 sb->s_maxbytes = (u64) 1 << 63;
2171 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2174 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2175 sb->s_time_gran = 100;
2177 /* on error free sesinfo and tcon struct if needed */
2179 /* if session setup failed, use count is zero but
2180 we still need to free cifsd thread */
2181 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2182 spin_lock(&GlobalMid_Lock);
2183 srvTcp->tcpStatus = CifsExiting;
2184 spin_unlock(&GlobalMid_Lock);
2186 struct task_struct *tsk;
2187 /* If we could verify that kthread_stop would
2188 always wake up processes blocked in
2189 tcp in recv_mesg then we could remove the
2191 force_sig(SIGKILL, srvTcp->tsk);
2197 /* If find_unc succeeded then rc == 0 so we can not end */
2198 if (tcon) /* up accidently freeing someone elses tcon struct */
2200 if (existingCifsSes == NULL) {
2202 if ((pSesInfo->server) &&
2203 (pSesInfo->status == CifsGood)) {
2205 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2206 /* if the socketUseCount is now zero */
2207 if ((temp_rc == -ESHUTDOWN) &&
2208 (pSesInfo->server) &&
2209 (pSesInfo->server->tsk)) {
2210 struct task_struct *tsk;
2212 pSesInfo->server->tsk);
2213 tsk = pSesInfo->server->tsk;
2218 cFYI(1, ("No session or bad tcon"));
2219 if ((pSesInfo->server) &&
2220 (pSesInfo->server->tsk)) {
2221 struct task_struct *tsk;
2223 pSesInfo->server->tsk);
2224 tsk = pSesInfo->server->tsk;
2229 sesInfoFree(pSesInfo);
2230 /* pSesInfo = NULL; */
2234 atomic_inc(&tcon->useCount);
2235 cifs_sb->tcon = tcon;
2236 tcon->ses = pSesInfo;
2238 /* do not care if following two calls succeed - informational */
2240 CIFSSMBQFSDeviceInfo(xid, tcon);
2241 CIFSSMBQFSAttributeInfo(xid, tcon);
2244 /* tell server which Unix caps we support */
2245 if (tcon->ses->capabilities & CAP_UNIX)
2246 /* reset of caps checks mount to see if unix extensions
2247 disabled for just this mount */
2248 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2250 tcon->unix_ext = 0; /* server does not support them */
2252 /* convert forward to back slashes in prepath here if needed */
2253 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2254 convert_delimiter(cifs_sb->prepath,
2255 CIFS_DIR_SEP(cifs_sb));
2257 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2258 cifs_sb->rsize = 1024 * 127;
2260 ("no very large read support, rsize now 127K"));
2262 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2263 cifs_sb->wsize = min(cifs_sb->wsize,
2264 (tcon->ses->server->maxBuf -
2265 MAX_CIFS_HDR_SIZE));
2266 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2267 cifs_sb->rsize = min(cifs_sb->rsize,
2268 (tcon->ses->server->maxBuf -
2269 MAX_CIFS_HDR_SIZE));
2272 /* volume_info.password is freed above when existing session found
2273 (in which case it is not needed anymore) but when new sesion is created
2274 the password ptr is put in the new session structure (in which case the
2275 password will be freed at unmount time) */
2277 /* zero out password before freeing */
2278 if (volume_info.password != NULL) {
2279 memset(volume_info.password, 0, strlen(volume_info.password));
2280 kfree(volume_info.password);
2282 kfree(volume_info.UNC);
2283 kfree(volume_info.prepath);
2289 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2290 char session_key[CIFS_SESS_KEY_SIZE],
2291 const struct nls_table *nls_codepage)
2293 struct smb_hdr *smb_buffer;
2294 struct smb_hdr *smb_buffer_response;
2295 SESSION_SETUP_ANDX *pSMB;
2296 SESSION_SETUP_ANDX *pSMBr;
2301 int remaining_words = 0;
2302 int bytes_returned = 0;
2307 cFYI(1, ("In sesssetup"));
2310 user = ses->userName;
2311 domain = ses->domainName;
2312 smb_buffer = cifs_buf_get();
2313 if (smb_buffer == NULL) {
2316 smb_buffer_response = smb_buffer;
2317 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2319 /* send SMBsessionSetup here */
2320 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2321 NULL /* no tCon exists yet */ , 13 /* wct */ );
2323 smb_buffer->Mid = GetNextMid(ses->server);
2324 pSMB->req_no_secext.AndXCommand = 0xFF;
2325 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2326 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2328 if (ses->server->secMode &
2329 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2330 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2332 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2333 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2334 if (ses->capabilities & CAP_UNICODE) {
2335 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2336 capabilities |= CAP_UNICODE;
2338 if (ses->capabilities & CAP_STATUS32) {
2339 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2340 capabilities |= CAP_STATUS32;
2342 if (ses->capabilities & CAP_DFS) {
2343 smb_buffer->Flags2 |= SMBFLG2_DFS;
2344 capabilities |= CAP_DFS;
2346 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2348 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2349 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2351 pSMB->req_no_secext.CaseSensitivePasswordLength =
2352 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2353 bcc_ptr = pByteArea(smb_buffer);
2354 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2355 bcc_ptr += CIFS_SESS_KEY_SIZE;
2356 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2357 bcc_ptr += CIFS_SESS_KEY_SIZE;
2359 if (ses->capabilities & CAP_UNICODE) {
2360 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2365 bytes_returned = 0; /* skip null user */
2368 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2370 /* convert number of 16 bit words to bytes */
2371 bcc_ptr += 2 * bytes_returned;
2372 bcc_ptr += 2; /* trailing null */
2375 cifs_strtoUCS((__le16 *) bcc_ptr,
2376 "CIFS_LINUX_DOM", 32, nls_codepage);
2379 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2381 bcc_ptr += 2 * bytes_returned;
2384 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2386 bcc_ptr += 2 * bytes_returned;
2388 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2390 bcc_ptr += 2 * bytes_returned;
2393 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2395 bcc_ptr += 2 * bytes_returned;
2399 strncpy(bcc_ptr, user, 200);
2400 bcc_ptr += strnlen(user, 200);
2404 if (domain == NULL) {
2405 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2406 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2408 strncpy(bcc_ptr, domain, 64);
2409 bcc_ptr += strnlen(domain, 64);
2413 strcpy(bcc_ptr, "Linux version ");
2414 bcc_ptr += strlen("Linux version ");
2415 strcpy(bcc_ptr, utsname()->release);
2416 bcc_ptr += strlen(utsname()->release) + 1;
2417 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2418 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2420 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2421 smb_buffer->smb_buf_length += count;
2422 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2424 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2425 &bytes_returned, CIFS_LONG_OP);
2427 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2428 } else if ((smb_buffer_response->WordCount == 3)
2429 || (smb_buffer_response->WordCount == 4)) {
2430 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2431 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2432 if (action & GUEST_LOGIN)
2433 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2434 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2436 cFYI(1, ("UID = %d ", ses->Suid));
2437 /* response can have either 3 or 4 word count - Samba sends 3 */
2438 bcc_ptr = pByteArea(smb_buffer_response);
2439 if ((pSMBr->resp.hdr.WordCount == 3)
2440 || ((pSMBr->resp.hdr.WordCount == 4)
2441 && (blob_len < pSMBr->resp.ByteCount))) {
2442 if (pSMBr->resp.hdr.WordCount == 4)
2443 bcc_ptr += blob_len;
2445 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2446 if ((long) (bcc_ptr) % 2) {
2448 (BCC(smb_buffer_response) - 1) / 2;
2449 /* Unicode strings must be word
2454 BCC(smb_buffer_response) / 2;
2457 UniStrnlen((wchar_t *) bcc_ptr,
2458 remaining_words - 1);
2459 /* We look for obvious messed up bcc or strings in response so we do not go off
2460 the end since (at least) WIN2K and Windows XP have a major bug in not null
2461 terminating last Unicode string in response */
2463 kfree(ses->serverOS);
2464 ses->serverOS = kzalloc(2 * (len + 1),
2466 if (ses->serverOS == NULL)
2467 goto sesssetup_nomem;
2468 cifs_strfromUCS_le(ses->serverOS,
2471 bcc_ptr += 2 * (len + 1);
2472 remaining_words -= len + 1;
2473 ses->serverOS[2 * len] = 0;
2474 ses->serverOS[1 + (2 * len)] = 0;
2475 if (remaining_words > 0) {
2476 len = UniStrnlen((wchar_t *)bcc_ptr,
2478 kfree(ses->serverNOS);
2479 ses->serverNOS = kzalloc(2 * (len + 1),
2481 if (ses->serverNOS == NULL)
2482 goto sesssetup_nomem;
2483 cifs_strfromUCS_le(ses->serverNOS,
2486 bcc_ptr += 2 * (len + 1);
2487 ses->serverNOS[2 * len] = 0;
2488 ses->serverNOS[1 + (2 * len)] = 0;
2489 if (strncmp(ses->serverNOS,
2490 "NT LAN Manager 4", 16) == 0) {
2491 cFYI(1, ("NT4 server"));
2492 ses->flags |= CIFS_SES_NT4;
2494 remaining_words -= len + 1;
2495 if (remaining_words > 0) {
2496 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2497 /* last string is not always null terminated
2498 (for e.g. for Windows XP & 2000) */
2499 if (ses->serverDomain)
2500 kfree(ses->serverDomain);
2504 if (ses->serverDomain == NULL)
2505 goto sesssetup_nomem;
2506 cifs_strfromUCS_le(ses->serverDomain,
2509 bcc_ptr += 2 * (len + 1);
2510 ses->serverDomain[2*len] = 0;
2511 ses->serverDomain[1+(2*len)] = 0;
2512 } else { /* else no more room so create
2513 dummy domain string */
2514 if (ses->serverDomain)
2515 kfree(ses->serverDomain);
2517 kzalloc(2, GFP_KERNEL);
2519 } else { /* no room so create dummy domain
2522 /* if these kcallocs fail not much we
2523 can do, but better to not fail the
2525 kfree(ses->serverDomain);
2527 kzalloc(2, GFP_KERNEL);
2528 kfree(ses->serverNOS);
2530 kzalloc(2, GFP_KERNEL);
2532 } else { /* ASCII */
2533 len = strnlen(bcc_ptr, 1024);
2534 if (((long) bcc_ptr + len) - (long)
2535 pByteArea(smb_buffer_response)
2536 <= BCC(smb_buffer_response)) {
2537 kfree(ses->serverOS);
2538 ses->serverOS = kzalloc(len + 1,
2540 if (ses->serverOS == NULL)
2541 goto sesssetup_nomem;
2542 strncpy(ses->serverOS, bcc_ptr, len);
2545 /* null terminate the string */
2549 len = strnlen(bcc_ptr, 1024);
2550 kfree(ses->serverNOS);
2551 ses->serverNOS = kzalloc(len + 1,
2553 if (ses->serverNOS == NULL)
2554 goto sesssetup_nomem;
2555 strncpy(ses->serverNOS, bcc_ptr, len);
2560 len = strnlen(bcc_ptr, 1024);
2561 if (ses->serverDomain)
2562 kfree(ses->serverDomain);
2563 ses->serverDomain = kzalloc(len + 1,
2565 if (ses->serverDomain == NULL)
2566 goto sesssetup_nomem;
2567 strncpy(ses->serverDomain, bcc_ptr,
2574 ("Variable field of length %d "
2575 "extends beyond end of smb ",
2580 (" Security Blob Length extends beyond "
2585 (" Invalid Word count %d: ",
2586 smb_buffer_response->WordCount));
2589 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2590 since that could make reconnection harder, and
2591 reconnection might be needed to free memory */
2592 cifs_buf_release(smb_buffer);
2598 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2599 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2600 const struct nls_table *nls_codepage)
2602 struct smb_hdr *smb_buffer;
2603 struct smb_hdr *smb_buffer_response;
2604 SESSION_SETUP_ANDX *pSMB;
2605 SESSION_SETUP_ANDX *pSMBr;
2609 int remaining_words = 0;
2610 int bytes_returned = 0;
2612 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2613 PNEGOTIATE_MESSAGE SecurityBlob;
2614 PCHALLENGE_MESSAGE SecurityBlob2;
2615 __u32 negotiate_flags, capabilities;
2618 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2621 domain = ses->domainName;
2622 *pNTLMv2_flag = false;
2623 smb_buffer = cifs_buf_get();
2624 if (smb_buffer == NULL) {
2627 smb_buffer_response = smb_buffer;
2628 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2629 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2631 /* send SMBsessionSetup here */
2632 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2633 NULL /* no tCon exists yet */ , 12 /* wct */ );
2635 smb_buffer->Mid = GetNextMid(ses->server);
2636 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2637 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2639 pSMB->req.AndXCommand = 0xFF;
2640 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2641 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2643 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2644 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2646 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2647 CAP_EXTENDED_SECURITY;
2648 if (ses->capabilities & CAP_UNICODE) {
2649 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2650 capabilities |= CAP_UNICODE;
2652 if (ses->capabilities & CAP_STATUS32) {
2653 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2654 capabilities |= CAP_STATUS32;
2656 if (ses->capabilities & CAP_DFS) {
2657 smb_buffer->Flags2 |= SMBFLG2_DFS;
2658 capabilities |= CAP_DFS;
2660 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2662 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2663 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2664 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2665 SecurityBlob->MessageType = NtLmNegotiate;
2667 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2668 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2669 NTLMSSP_NEGOTIATE_56 |
2670 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2672 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2673 /* if (ntlmv2_support)
2674 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2675 /* setup pointers to domain name and workstation name */
2676 bcc_ptr += SecurityBlobLength;
2678 SecurityBlob->WorkstationName.Buffer = 0;
2679 SecurityBlob->WorkstationName.Length = 0;
2680 SecurityBlob->WorkstationName.MaximumLength = 0;
2682 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2683 along with username on auth request (ie the response to challenge) */
2684 SecurityBlob->DomainName.Buffer = 0;
2685 SecurityBlob->DomainName.Length = 0;
2686 SecurityBlob->DomainName.MaximumLength = 0;
2687 if (ses->capabilities & CAP_UNICODE) {
2688 if ((long) bcc_ptr % 2) {
2694 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2696 bcc_ptr += 2 * bytes_returned;
2698 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2700 bcc_ptr += 2 * bytes_returned;
2701 bcc_ptr += 2; /* null terminate Linux version */
2703 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2705 bcc_ptr += 2 * bytes_returned;
2708 bcc_ptr += 2; /* null terminate network opsys string */
2711 bcc_ptr += 2; /* null domain */
2712 } else { /* ASCII */
2713 strcpy(bcc_ptr, "Linux version ");
2714 bcc_ptr += strlen("Linux version ");
2715 strcpy(bcc_ptr, utsname()->release);
2716 bcc_ptr += strlen(utsname()->release) + 1;
2717 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2718 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2719 bcc_ptr++; /* empty domain field */
2722 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2723 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2724 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2725 smb_buffer->smb_buf_length += count;
2726 pSMB->req.ByteCount = cpu_to_le16(count);
2728 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2729 &bytes_returned, CIFS_LONG_OP);
2731 if (smb_buffer_response->Status.CifsError ==
2732 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2736 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2737 } else if ((smb_buffer_response->WordCount == 3)
2738 || (smb_buffer_response->WordCount == 4)) {
2739 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2740 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2742 if (action & GUEST_LOGIN)
2743 cFYI(1, (" Guest login"));
2744 /* Do we want to set anything in SesInfo struct when guest login? */
2746 bcc_ptr = pByteArea(smb_buffer_response);
2747 /* response can have either 3 or 4 word count - Samba sends 3 */
2749 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2750 if (SecurityBlob2->MessageType != NtLmChallenge) {
2752 ("Unexpected NTLMSSP message type received %d",
2753 SecurityBlob2->MessageType));
2755 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2756 cFYI(1, ("UID = %d", ses->Suid));
2757 if ((pSMBr->resp.hdr.WordCount == 3)
2758 || ((pSMBr->resp.hdr.WordCount == 4)
2760 pSMBr->resp.ByteCount))) {
2762 if (pSMBr->resp.hdr.WordCount == 4) {
2763 bcc_ptr += blob_len;
2764 cFYI(1, ("Security Blob Length %d",
2768 cFYI(1, ("NTLMSSP Challenge rcvd"));
2770 memcpy(ses->server->cryptKey,
2771 SecurityBlob2->Challenge,
2772 CIFS_CRYPTO_KEY_SIZE);
2773 if (SecurityBlob2->NegotiateFlags &
2774 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2775 *pNTLMv2_flag = true;
2777 if ((SecurityBlob2->NegotiateFlags &
2778 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2779 || (sign_CIFS_PDUs > 1))
2780 ses->server->secMode |=
2781 SECMODE_SIGN_REQUIRED;
2782 if ((SecurityBlob2->NegotiateFlags &
2783 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2784 ses->server->secMode |=
2785 SECMODE_SIGN_ENABLED;
2787 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2788 if ((long) (bcc_ptr) % 2) {
2790 (BCC(smb_buffer_response)
2792 /* Must word align unicode strings */
2797 (smb_buffer_response) / 2;
2800 UniStrnlen((wchar_t *) bcc_ptr,
2801 remaining_words - 1);
2802 /* We look for obvious messed up bcc or strings in response so we do not go off
2803 the end since (at least) WIN2K and Windows XP have a major bug in not null
2804 terminating last Unicode string in response */
2806 kfree(ses->serverOS);
2808 kzalloc(2 * (len + 1), GFP_KERNEL);
2809 cifs_strfromUCS_le(ses->serverOS,
2813 bcc_ptr += 2 * (len + 1);
2814 remaining_words -= len + 1;
2815 ses->serverOS[2 * len] = 0;
2816 ses->serverOS[1 + (2 * len)] = 0;
2817 if (remaining_words > 0) {
2818 len = UniStrnlen((wchar_t *)
2822 kfree(ses->serverNOS);
2824 kzalloc(2 * (len + 1),
2826 cifs_strfromUCS_le(ses->
2832 bcc_ptr += 2 * (len + 1);
2833 ses->serverNOS[2 * len] = 0;
2836 remaining_words -= len + 1;
2837 if (remaining_words > 0) {
2838 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2839 /* last string not always null terminated
2840 (for e.g. for Windows XP & 2000) */
2841 kfree(ses->serverDomain);
2853 ses->serverDomain[2*len]
2858 } /* else no more room so create dummy domain string */
2860 kfree(ses->serverDomain);
2865 } else { /* no room so create dummy domain and NOS string */
2866 kfree(ses->serverDomain);
2868 kzalloc(2, GFP_KERNEL);
2869 kfree(ses->serverNOS);
2871 kzalloc(2, GFP_KERNEL);
2873 } else { /* ASCII */
2874 len = strnlen(bcc_ptr, 1024);
2875 if (((long) bcc_ptr + len) - (long)
2876 pByteArea(smb_buffer_response)
2877 <= BCC(smb_buffer_response)) {
2879 kfree(ses->serverOS);
2883 strncpy(ses->serverOS,
2887 bcc_ptr[0] = 0; /* null terminate string */
2890 len = strnlen(bcc_ptr, 1024);
2891 kfree(ses->serverNOS);
2895 strncpy(ses->serverNOS, bcc_ptr, len);
2900 len = strnlen(bcc_ptr, 1024);
2901 kfree(ses->serverDomain);
2905 strncpy(ses->serverDomain,
2912 ("field of length %d "
2913 "extends beyond end of smb",
2917 cERROR(1, ("Security Blob Length extends beyond"
2921 cERROR(1, ("No session structure passed in."));
2925 (" Invalid Word count %d:",
2926 smb_buffer_response->WordCount));
2930 cifs_buf_release(smb_buffer);
2935 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2936 char *ntlm_session_key, bool ntlmv2_flag,
2937 const struct nls_table *nls_codepage)
2939 struct smb_hdr *smb_buffer;
2940 struct smb_hdr *smb_buffer_response;
2941 SESSION_SETUP_ANDX *pSMB;
2942 SESSION_SETUP_ANDX *pSMBr;
2947 int remaining_words = 0;
2948 int bytes_returned = 0;
2950 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2951 PAUTHENTICATE_MESSAGE SecurityBlob;
2952 __u32 negotiate_flags, capabilities;
2955 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2958 user = ses->userName;
2959 domain = ses->domainName;
2960 smb_buffer = cifs_buf_get();
2961 if (smb_buffer == NULL) {
2964 smb_buffer_response = smb_buffer;
2965 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2966 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2968 /* send SMBsessionSetup here */
2969 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2970 NULL /* no tCon exists yet */ , 12 /* wct */ );
2972 smb_buffer->Mid = GetNextMid(ses->server);
2973 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2974 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2975 pSMB->req.AndXCommand = 0xFF;
2976 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2977 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2979 pSMB->req.hdr.Uid = ses->Suid;
2981 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2982 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2984 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2985 CAP_EXTENDED_SECURITY;
2986 if (ses->capabilities & CAP_UNICODE) {
2987 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2988 capabilities |= CAP_UNICODE;
2990 if (ses->capabilities & CAP_STATUS32) {
2991 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2992 capabilities |= CAP_STATUS32;
2994 if (ses->capabilities & CAP_DFS) {
2995 smb_buffer->Flags2 |= SMBFLG2_DFS;
2996 capabilities |= CAP_DFS;
2998 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3000 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3001 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3002 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3003 SecurityBlob->MessageType = NtLmAuthenticate;
3004 bcc_ptr += SecurityBlobLength;
3005 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3006 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3007 0x80000000 | NTLMSSP_NEGOTIATE_128;
3009 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3011 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3013 /* setup pointers to domain name and workstation name */
3015 SecurityBlob->WorkstationName.Buffer = 0;
3016 SecurityBlob->WorkstationName.Length = 0;
3017 SecurityBlob->WorkstationName.MaximumLength = 0;
3018 SecurityBlob->SessionKey.Length = 0;
3019 SecurityBlob->SessionKey.MaximumLength = 0;
3020 SecurityBlob->SessionKey.Buffer = 0;
3022 SecurityBlob->LmChallengeResponse.Length = 0;
3023 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3024 SecurityBlob->LmChallengeResponse.Buffer = 0;
3026 SecurityBlob->NtChallengeResponse.Length =
3027 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3028 SecurityBlob->NtChallengeResponse.MaximumLength =
3029 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3030 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3031 SecurityBlob->NtChallengeResponse.Buffer =
3032 cpu_to_le32(SecurityBlobLength);
3033 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3034 bcc_ptr += CIFS_SESS_KEY_SIZE;
3036 if (ses->capabilities & CAP_UNICODE) {
3037 if (domain == NULL) {
3038 SecurityBlob->DomainName.Buffer = 0;
3039 SecurityBlob->DomainName.Length = 0;
3040 SecurityBlob->DomainName.MaximumLength = 0;
3042 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3045 SecurityBlob->DomainName.MaximumLength =
3047 SecurityBlob->DomainName.Buffer =
3048 cpu_to_le32(SecurityBlobLength);
3050 SecurityBlobLength += ln;
3051 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3054 SecurityBlob->UserName.Buffer = 0;
3055 SecurityBlob->UserName.Length = 0;
3056 SecurityBlob->UserName.MaximumLength = 0;
3058 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3061 SecurityBlob->UserName.MaximumLength =
3063 SecurityBlob->UserName.Buffer =
3064 cpu_to_le32(SecurityBlobLength);
3066 SecurityBlobLength += ln;
3067 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3070 /* SecurityBlob->WorkstationName.Length =
3071 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3072 SecurityBlob->WorkstationName.Length *= 2;
3073 SecurityBlob->WorkstationName.MaximumLength =
3074 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3075 SecurityBlob->WorkstationName.Buffer =
3076 cpu_to_le32(SecurityBlobLength);
3077 bcc_ptr += SecurityBlob->WorkstationName.Length;
3078 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3079 SecurityBlob->WorkstationName.Length =
3080 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3082 if ((long) bcc_ptr % 2) {
3087 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3089 bcc_ptr += 2 * bytes_returned;
3091 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3093 bcc_ptr += 2 * bytes_returned;
3094 bcc_ptr += 2; /* null term version string */
3096 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3098 bcc_ptr += 2 * bytes_returned;
3101 bcc_ptr += 2; /* null terminate network opsys string */
3104 bcc_ptr += 2; /* null domain */
3105 } else { /* ASCII */
3106 if (domain == NULL) {
3107 SecurityBlob->DomainName.Buffer = 0;
3108 SecurityBlob->DomainName.Length = 0;
3109 SecurityBlob->DomainName.MaximumLength = 0;
3112 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3113 strncpy(bcc_ptr, domain, 63);
3114 ln = strnlen(domain, 64);
3115 SecurityBlob->DomainName.MaximumLength =
3117 SecurityBlob->DomainName.Buffer =
3118 cpu_to_le32(SecurityBlobLength);
3120 SecurityBlobLength += ln;
3121 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3124 SecurityBlob->UserName.Buffer = 0;
3125 SecurityBlob->UserName.Length = 0;
3126 SecurityBlob->UserName.MaximumLength = 0;
3129 strncpy(bcc_ptr, user, 63);
3130 ln = strnlen(user, 64);
3131 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3132 SecurityBlob->UserName.Buffer =
3133 cpu_to_le32(SecurityBlobLength);
3135 SecurityBlobLength += ln;
3136 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3138 /* BB fill in our workstation name if known BB */
3140 strcpy(bcc_ptr, "Linux version ");
3141 bcc_ptr += strlen("Linux version ");
3142 strcpy(bcc_ptr, utsname()->release);
3143 bcc_ptr += strlen(utsname()->release) + 1;
3144 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3145 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3146 bcc_ptr++; /* null domain */
3149 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3150 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3151 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3152 smb_buffer->smb_buf_length += count;
3153 pSMB->req.ByteCount = cpu_to_le16(count);
3155 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3156 &bytes_returned, CIFS_LONG_OP);
3158 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3159 } else if ((smb_buffer_response->WordCount == 3) ||
3160 (smb_buffer_response->WordCount == 4)) {
3161 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3162 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3163 if (action & GUEST_LOGIN)
3164 cFYI(1, (" Guest login")); /* BB Should we set anything
3165 in SesInfo struct ? */
3166 /* if (SecurityBlob2->MessageType != NtLm??) {
3167 cFYI("Unexpected message type on auth response is %d"));
3172 ("Check challenge UID %d vs auth response UID %d",
3173 ses->Suid, smb_buffer_response->Uid));
3174 /* UID left in wire format */
3175 ses->Suid = smb_buffer_response->Uid;
3176 bcc_ptr = pByteArea(smb_buffer_response);
3177 /* response can have either 3 or 4 word count - Samba sends 3 */
3178 if ((pSMBr->resp.hdr.WordCount == 3)
3179 || ((pSMBr->resp.hdr.WordCount == 4)
3181 pSMBr->resp.ByteCount))) {
3182 if (pSMBr->resp.hdr.WordCount == 4) {
3186 ("Security Blob Length %d ",
3191 ("NTLMSSP response to Authenticate "));
3193 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3194 if ((long) (bcc_ptr) % 2) {
3196 (BCC(smb_buffer_response)
3198 bcc_ptr++; /* Unicode strings must be word aligned */
3200 remaining_words = BCC(smb_buffer_response) / 2;
3202 len = UniStrnlen((wchar_t *) bcc_ptr,
3203 remaining_words - 1);
3204 /* We look for obvious messed up bcc or strings in response so we do not go off
3205 the end since (at least) WIN2K and Windows XP have a major bug in not null
3206 terminating last Unicode string in response */
3208 kfree(ses->serverOS);
3210 kzalloc(2 * (len + 1), GFP_KERNEL);
3211 cifs_strfromUCS_le(ses->serverOS,
3215 bcc_ptr += 2 * (len + 1);
3216 remaining_words -= len + 1;
3217 ses->serverOS[2 * len] = 0;
3218 ses->serverOS[1 + (2 * len)] = 0;
3219 if (remaining_words > 0) {
3220 len = UniStrnlen((wchar_t *)
3224 kfree(ses->serverNOS);
3226 kzalloc(2 * (len + 1),
3228 cifs_strfromUCS_le(ses->
3234 bcc_ptr += 2 * (len + 1);
3235 ses->serverNOS[2 * len] = 0;
3236 ses->serverNOS[1+(2*len)] = 0;
3237 remaining_words -= len + 1;
3238 if (remaining_words > 0) {
3239 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3240 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3241 if (ses->serverDomain)
3242 kfree(ses->serverDomain);
3267 } /* else no more room so create dummy domain string */
3269 if (ses->serverDomain)
3270 kfree(ses->serverDomain);
3271 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3273 } else { /* no room so create dummy domain and NOS string */
3274 if (ses->serverDomain)
3275 kfree(ses->serverDomain);
3276 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3277 kfree(ses->serverNOS);
3278 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3280 } else { /* ASCII */
3281 len = strnlen(bcc_ptr, 1024);
3282 if (((long) bcc_ptr + len) -
3283 (long) pByteArea(smb_buffer_response)
3284 <= BCC(smb_buffer_response)) {
3286 kfree(ses->serverOS);
3287 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3288 strncpy(ses->serverOS,bcc_ptr, len);
3291 bcc_ptr[0] = 0; /* null terminate the string */
3294 len = strnlen(bcc_ptr, 1024);
3295 kfree(ses->serverNOS);
3296 ses->serverNOS = kzalloc(len+1,
3298 strncpy(ses->serverNOS,
3304 len = strnlen(bcc_ptr, 1024);
3305 if (ses->serverDomain)
3306 kfree(ses->serverDomain);
3310 strncpy(ses->serverDomain,
3316 cFYI(1, ("field of length %d "
3317 "extends beyond end of smb ",
3321 cERROR(1, ("Security Blob extends beyond end "
3325 cERROR(1, ("No session structure passed in."));
3328 cERROR(1, ("Invalid Word count %d: ",
3329 smb_buffer_response->WordCount));
3333 cifs_buf_release(smb_buffer);
3339 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3340 const char *tree, struct cifsTconInfo *tcon,
3341 const struct nls_table *nls_codepage)
3343 struct smb_hdr *smb_buffer;
3344 struct smb_hdr *smb_buffer_response;
3347 unsigned char *bcc_ptr;
3355 smb_buffer = cifs_buf_get();
3356 if (smb_buffer == NULL) {
3359 smb_buffer_response = smb_buffer;
3361 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3362 NULL /*no tid */ , 4 /*wct */ );
3364 smb_buffer->Mid = GetNextMid(ses->server);
3365 smb_buffer->Uid = ses->Suid;
3366 pSMB = (TCONX_REQ *) smb_buffer;
3367 pSMBr = (TCONX_RSP *) smb_buffer_response;
3369 pSMB->AndXCommand = 0xFF;
3370 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3371 bcc_ptr = &pSMB->Password[0];
3372 if ((ses->server->secMode) & SECMODE_USER) {
3373 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3374 *bcc_ptr = 0; /* password is null byte */
3375 bcc_ptr++; /* skip password */
3376 /* already aligned so no need to do it below */
3378 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3379 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3380 specified as required (when that support is added to
3381 the vfs in the future) as only NTLM or the much
3382 weaker LANMAN (which we do not send by default) is accepted
3383 by Samba (not sure whether other servers allow
3384 NTLMv2 password here) */
3385 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3386 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3387 (ses->server->secType == LANMAN))
3388 calc_lanman_hash(ses, bcc_ptr);
3390 #endif /* CIFS_WEAK_PW_HASH */
3391 SMBNTencrypt(ses->password,
3392 ses->server->cryptKey,
3395 bcc_ptr += CIFS_SESS_KEY_SIZE;
3396 if (ses->capabilities & CAP_UNICODE) {
3397 /* must align unicode strings */
3398 *bcc_ptr = 0; /* null byte password */
3403 if (ses->server->secMode &
3404 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3405 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3407 if (ses->capabilities & CAP_STATUS32) {
3408 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3410 if (ses->capabilities & CAP_DFS) {
3411 smb_buffer->Flags2 |= SMBFLG2_DFS;
3413 if (ses->capabilities & CAP_UNICODE) {
3414 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3416 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3417 6 /* max utf8 char length in bytes */ *
3418 (/* server len*/ + 256 /* share len */), nls_codepage);
3419 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3420 bcc_ptr += 2; /* skip trailing null */
3421 } else { /* ASCII */
3422 strcpy(bcc_ptr, tree);
3423 bcc_ptr += strlen(tree) + 1;
3425 strcpy(bcc_ptr, "?????");
3426 bcc_ptr += strlen("?????");
3428 count = bcc_ptr - &pSMB->Password[0];
3429 pSMB->hdr.smb_buf_length += count;
3430 pSMB->ByteCount = cpu_to_le16(count);
3432 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3435 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3436 /* above now done in SendReceive */
3437 if ((rc == 0) && (tcon != NULL)) {
3438 tcon->tidStatus = CifsGood;
3439 tcon->tid = smb_buffer_response->Tid;
3440 bcc_ptr = pByteArea(smb_buffer_response);
3441 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3442 /* skip service field (NB: this field is always ASCII) */
3444 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3445 (bcc_ptr[2] == 'C')) {
3446 cFYI(1, ("IPC connection"));
3449 } else if (length == 2) {
3450 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3451 /* the most common case */
3452 cFYI(1, ("disk share connection"));
3455 bcc_ptr += length + 1;
3456 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3457 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3458 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3459 if ((bcc_ptr + (2 * length)) -
3460 pByteArea(smb_buffer_response) <=
3461 BCC(smb_buffer_response)) {
3462 kfree(tcon->nativeFileSystem);
3463 tcon->nativeFileSystem =
3464 kzalloc(length + 2, GFP_KERNEL);
3465 if (tcon->nativeFileSystem)
3467 tcon->nativeFileSystem,
3469 length, nls_codepage);
3470 bcc_ptr += 2 * length;
3471 bcc_ptr[0] = 0; /* null terminate the string */
3475 /* else do not bother copying these information fields*/
3477 length = strnlen(bcc_ptr, 1024);
3478 if ((bcc_ptr + length) -
3479 pByteArea(smb_buffer_response) <=
3480 BCC(smb_buffer_response)) {
3481 kfree(tcon->nativeFileSystem);
3482 tcon->nativeFileSystem =
3483 kzalloc(length + 1, GFP_KERNEL);
3484 if (tcon->nativeFileSystem)
3485 strncpy(tcon->nativeFileSystem, bcc_ptr,
3488 /* else do not bother copying these information fields*/
3490 if ((smb_buffer_response->WordCount == 3) ||
3491 (smb_buffer_response->WordCount == 7))
3492 /* field is in same location */
3493 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3496 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3497 } else if ((rc == 0) && tcon == NULL) {
3498 /* all we need to save for IPC$ connection */
3499 ses->ipc_tid = smb_buffer_response->Tid;
3502 cifs_buf_release(smb_buffer);
3507 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3511 struct cifsSesInfo *ses = NULL;
3512 struct task_struct *cifsd_task;
3517 if (cifs_sb->tcon) {
3518 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3519 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3524 DeleteTconOplockQEntries(cifs_sb->tcon);
3525 tconInfoFree(cifs_sb->tcon);
3526 if ((ses) && (ses->server)) {
3527 /* save off task so we do not refer to ses later */
3528 cifsd_task = ses->server->tsk;
3529 cFYI(1, ("About to do SMBLogoff "));
3530 rc = CIFSSMBLogoff(xid, ses);
3534 } else if (rc == -ESHUTDOWN) {
3535 cFYI(1, ("Waking up socket by sending signal"));
3537 force_sig(SIGKILL, cifsd_task);
3538 kthread_stop(cifsd_task);
3541 } /* else - we have an smb session
3542 left on this socket do not kill cifsd */
3544 cFYI(1, ("No session or bad tcon"));
3547 cifs_sb->tcon = NULL;
3548 tmp = cifs_sb->prepath;
3549 cifs_sb->prepathlen = 0;
3550 cifs_sb->prepath = NULL;
3559 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3560 struct nls_table *nls_info)
3563 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3564 bool ntlmv2_flag = false;
3567 /* what if server changes its buffer size after dropping the session? */
3568 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3569 rc = CIFSSMBNegotiate(xid, pSesInfo);
3570 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3571 rc = CIFSSMBNegotiate(xid, pSesInfo);
3576 spin_lock(&GlobalMid_Lock);
3577 if (pSesInfo->server->tcpStatus != CifsExiting)
3578 pSesInfo->server->tcpStatus = CifsGood;
3581 spin_unlock(&GlobalMid_Lock);
3587 pSesInfo->flags = 0;
3588 pSesInfo->capabilities = pSesInfo->server->capabilities;
3589 if (linuxExtEnabled == 0)
3590 pSesInfo->capabilities &= (~CAP_UNIX);
3591 /* pSesInfo->sequence_number = 0;*/
3593 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3594 pSesInfo->server->secMode,
3595 pSesInfo->server->capabilities,
3596 pSesInfo->server->timeAdj));
3597 if (experimEnabled < 2)
3598 rc = CIFS_SessSetup(xid, pSesInfo,
3599 first_time, nls_info);
3600 else if (extended_security
3601 && (pSesInfo->capabilities
3602 & CAP_EXTENDED_SECURITY)
3603 && (pSesInfo->server->secType == NTLMSSP)) {
3605 } else if (extended_security
3606 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3607 && (pSesInfo->server->secType == RawNTLMSSP)) {
3608 cFYI(1, ("NTLMSSP sesssetup"));
3609 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3616 cFYI(1, ("more secure NTLM ver2 hash"));
3617 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3622 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3624 CalcNTLMv2_response(pSesInfo,
3627 cifs_calculate_ntlmv2_mac_key(
3628 pSesInfo->server->mac_signing_key,
3629 response, ntlm_session_key,*/
3631 /* BB Put dummy sig in SessSetup PDU? */
3638 SMBNTencrypt(pSesInfo->password,
3639 pSesInfo->server->cryptKey,
3643 cifs_calculate_mac_key(
3644 &pSesInfo->server->mac_signing_key,
3646 pSesInfo->password);
3648 /* for better security the weaker lanman hash not sent
3649 in AuthSessSetup so we no longer calculate it */
3651 rc = CIFSNTLMSSPAuthSessSetup(xid,
3657 } else { /* old style NTLM 0.12 session setup */
3658 SMBNTencrypt(pSesInfo->password,
3659 pSesInfo->server->cryptKey,
3663 cifs_calculate_mac_key(
3664 &pSesInfo->server->mac_signing_key,
3665 ntlm_session_key, pSesInfo->password);
3667 rc = CIFSSessSetup(xid, pSesInfo,
3668 ntlm_session_key, nls_info);
3671 cERROR(1, ("Send error in SessSetup = %d", rc));
3673 cFYI(1, ("CIFS Session Established successfully"));
3674 pSesInfo->status = CifsGood;