4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 extern mempool_t *cifs_req_poolp;
63 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
64 char *iocharset; /* local code page for mapping to and from Unicode */
65 char source_rfc1001_name[16]; /* netbios name of client */
66 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
80 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
83 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool remap:1; /* set to remap seven reserved chars in filenames */
86 bool posix_paths:1; /* unset to not ask for posix pathnames. */
89 bool nullauth:1; /* attempt to authenticate with null user */
90 unsigned nocase; /* request case insensitive filenames */
91 unsigned nobrl; /* disable sending byte range locks to srv */
95 unsigned short int port;
99 static int ipv4_connect(struct sockaddr_in *psin_server,
100 struct socket **csocket,
102 char *server_netb_name);
103 static int ipv6_connect(struct sockaddr_in6 *psin_server,
104 struct socket **csocket);
108 * cifs tcp session reconnection
110 * mark tcp session as reconnecting so temporarily locked
111 * mark all smb sessions as reconnecting for tcp session
112 * reconnect tcp session
113 * wake up waiters on reconnection? - (not needed currently)
117 cifs_reconnect(struct TCP_Server_Info *server)
120 struct list_head *tmp;
121 struct cifsSesInfo *ses;
122 struct cifsTconInfo *tcon;
123 struct mid_q_entry *mid_entry;
125 spin_lock(&GlobalMid_Lock);
126 if (kthread_should_stop()) {
127 /* the demux thread will exit normally
128 next time through the loop */
129 spin_unlock(&GlobalMid_Lock);
132 server->tcpStatus = CifsNeedReconnect;
133 spin_unlock(&GlobalMid_Lock);
136 cFYI(1, ("Reconnecting tcp session"));
138 /* before reconnecting the tcp session, mark the smb session (uid)
139 and the tid bad so they are not used until reconnected */
140 read_lock(&GlobalSMBSeslock);
141 list_for_each(tmp, &GlobalSMBSessionList) {
142 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
144 if (ses->server == server) {
145 ses->status = CifsNeedReconnect;
149 /* else tcp and smb sessions need reconnection */
151 list_for_each(tmp, &GlobalTreeConnectionList) {
152 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
153 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
154 tcon->tidStatus = CifsNeedReconnect;
156 read_unlock(&GlobalSMBSeslock);
157 /* do not want to be sending data on a socket we are freeing */
158 down(&server->tcpSem);
159 if (server->ssocket) {
160 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
161 server->ssocket->flags));
162 kernel_sock_shutdown(server->ssocket, SHUT_WR);
163 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
164 server->ssocket->state,
165 server->ssocket->flags));
166 sock_release(server->ssocket);
167 server->ssocket = NULL;
170 spin_lock(&GlobalMid_Lock);
171 list_for_each(tmp, &server->pending_mid_q) {
172 mid_entry = list_entry(tmp, struct
176 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
177 /* Mark other intransit requests as needing
178 retry so we do not immediately mark the
179 session bad again (ie after we reconnect
180 below) as they timeout too */
181 mid_entry->midState = MID_RETRY_NEEDED;
185 spin_unlock(&GlobalMid_Lock);
188 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
190 if (server->protocolType == IPV6) {
191 rc = ipv6_connect(&server->addr.sockAddr6,
194 rc = ipv4_connect(&server->addr.sockAddr,
196 server->workstation_RFC1001_name,
197 server->server_RFC1001_name);
200 cFYI(1, ("reconnect error %d", rc));
203 atomic_inc(&tcpSesReconnectCount);
204 spin_lock(&GlobalMid_Lock);
205 if (!kthread_should_stop())
206 server->tcpStatus = CifsGood;
207 server->sequence_number = 0;
208 spin_unlock(&GlobalMid_Lock);
209 /* atomic_set(&server->inFlight,0);*/
210 wake_up(&server->response_q);
218 0 not a transact2, or all data present
219 >0 transact2 with that much data missing
220 -EINVAL = invalid transact2
223 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
225 struct smb_t2_rsp *pSMBt;
227 int data_in_this_rsp;
230 if (pSMB->Command != SMB_COM_TRANSACTION2)
233 /* check for plausible wct, bcc and t2 data and parm sizes */
234 /* check for parm and data offset going beyond end of smb */
235 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
236 cFYI(1, ("invalid transact2 word count"));
240 pSMBt = (struct smb_t2_rsp *)pSMB;
242 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
243 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
245 remaining = total_data_size - data_in_this_rsp;
249 else if (remaining < 0) {
250 cFYI(1, ("total data %d smaller than data in frame %d",
251 total_data_size, data_in_this_rsp));
254 cFYI(1, ("missing %d bytes from transact2, check next response",
256 if (total_data_size > maxBufSize) {
257 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
258 total_data_size, maxBufSize));
265 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
267 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
268 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
273 char *data_area_of_target;
274 char *data_area_of_buf2;
277 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
279 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
280 cFYI(1, ("total data size of primary and secondary t2 differ"));
283 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
285 remaining = total_data_size - total_in_buf;
290 if (remaining == 0) /* nothing to do, ignore */
293 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
294 if (remaining < total_in_buf2) {
295 cFYI(1, ("transact2 2nd response contains too much data"));
298 /* find end of first SMB data area */
299 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
300 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
301 /* validate target area */
303 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
304 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
306 data_area_of_target += total_in_buf;
308 /* copy second buffer into end of first buffer */
309 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
310 total_in_buf += total_in_buf2;
311 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
312 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
313 byte_count += total_in_buf2;
314 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
316 byte_count = pTargetSMB->smb_buf_length;
317 byte_count += total_in_buf2;
319 /* BB also add check that we are not beyond maximum buffer size */
321 pTargetSMB->smb_buf_length = byte_count;
323 if (remaining == total_in_buf2) {
324 cFYI(1, ("found the last secondary response"));
325 return 0; /* we are done */
326 } else /* more responses to go */
332 cifs_demultiplex_thread(struct TCP_Server_Info *server)
335 unsigned int pdu_length, total_read;
336 struct smb_hdr *smb_buffer = NULL;
337 struct smb_hdr *bigbuf = NULL;
338 struct smb_hdr *smallbuf = NULL;
339 struct msghdr smb_msg;
341 struct socket *csocket = server->ssocket;
342 struct list_head *tmp;
343 struct cifsSesInfo *ses;
344 struct task_struct *task_to_wake = NULL;
345 struct mid_q_entry *mid_entry;
347 bool isLargeBuf = false;
351 current->flags |= PF_MEMALLOC;
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;
654 spin_unlock(&GlobalMid_Lock);
656 /* don't exit until kthread_stop is called */
657 set_current_state(TASK_UNINTERRUPTIBLE);
658 while (!kthread_should_stop()) {
660 set_current_state(TASK_UNINTERRUPTIBLE);
662 set_current_state(TASK_RUNNING);
664 /* check if we have blocked requests that need to free */
665 /* Note that cifs_max_pending is normally 50, but
666 can be set at module install time to as little as two */
667 spin_lock(&GlobalMid_Lock);
668 if (atomic_read(&server->inFlight) >= cifs_max_pending)
669 atomic_set(&server->inFlight, cifs_max_pending - 1);
670 /* We do not want to set the max_pending too low or we
671 could end up with the counter going negative */
672 spin_unlock(&GlobalMid_Lock);
673 /* Although there should not be any requests blocked on
674 this queue it can not hurt to be paranoid and try to wake up requests
675 that may haven been blocked when more than 50 at time were on the wire
676 to the same server - they now will see the session is in exit state
677 and get out of SendReceive. */
678 wake_up_all(&server->request_q);
679 /* give those requests time to exit */
682 if (server->ssocket) {
683 sock_release(csocket);
684 server->ssocket = NULL;
686 /* buffer usuallly freed in free_mid - need to free it here on exit */
687 cifs_buf_release(bigbuf);
688 if (smallbuf) /* no sense logging a debug message if NULL */
689 cifs_small_buf_release(smallbuf);
691 read_lock(&GlobalSMBSeslock);
692 if (list_empty(&server->pending_mid_q)) {
693 /* loop through server session structures attached to this and
695 list_for_each(tmp, &GlobalSMBSessionList) {
697 list_entry(tmp, struct cifsSesInfo,
699 if (ses->server == server) {
700 ses->status = CifsExiting;
704 read_unlock(&GlobalSMBSeslock);
706 /* although we can not zero the server struct pointer yet,
707 since there are active requests which may depnd on them,
708 mark the corresponding SMB sessions as exiting too */
709 list_for_each(tmp, &GlobalSMBSessionList) {
710 ses = list_entry(tmp, struct cifsSesInfo,
712 if (ses->server == server)
713 ses->status = CifsExiting;
716 spin_lock(&GlobalMid_Lock);
717 list_for_each(tmp, &server->pending_mid_q) {
718 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
719 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
720 cFYI(1, ("Clearing Mid 0x%x - waking up ",
722 task_to_wake = mid_entry->tsk;
724 wake_up_process(task_to_wake);
727 spin_unlock(&GlobalMid_Lock);
728 read_unlock(&GlobalSMBSeslock);
729 /* 1/8th of sec is more than enough time for them to exit */
733 if (!list_empty(&server->pending_mid_q)) {
734 /* mpx threads have not exited yet give them
735 at least the smb send timeout time for long ops */
736 /* due to delays on oplock break requests, we need
737 to wait at least 45 seconds before giving up
738 on a request getting a response and going ahead
740 cFYI(1, ("Wait for exit from demultiplex thread"));
742 /* if threads still have not exited they are probably never
743 coming home not much else we can do but free the memory */
746 write_lock(&GlobalSMBSeslock);
747 atomic_dec(&tcpSesAllocCount);
748 length = tcpSesAllocCount.counter;
750 /* last chance to mark ses pointers invalid
751 if there are any pointing to this (e.g
752 if a crazy root user tried to kill cifsd
753 kernel thread explicitly this might happen) */
754 list_for_each(tmp, &GlobalSMBSessionList) {
755 ses = list_entry(tmp, struct cifsSesInfo,
757 if (ses->server == server)
760 write_unlock(&GlobalSMBSeslock);
762 kfree(server->hostname);
765 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
771 /* extract the host portion of the UNC string */
773 extract_hostname(const char *unc)
779 /* skip double chars at beginning of string */
780 /* BB: check validity of these bytes? */
783 /* delimiter between hostname and sharename is always '\\' now */
784 delim = strchr(src, '\\');
786 return ERR_PTR(-EINVAL);
789 dst = kmalloc((len + 1), GFP_KERNEL);
791 return ERR_PTR(-ENOMEM);
793 memcpy(dst, src, len);
800 cifs_parse_mount_options(char *options, const char *devname,
805 unsigned int temp_len, i, j;
811 if (Local_System_Name[0] != 0)
812 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
814 char *nodename = utsname()->nodename;
815 int n = strnlen(nodename, 15);
816 memset(vol->source_rfc1001_name, 0x20, 15);
817 for (i = 0; i < n; i++) {
818 /* does not have to be perfect mapping since field is
819 informational, only used for servers that do not support
820 port 445 and it can be overridden at mount time */
821 vol->source_rfc1001_name[i] = toupper(nodename[i]);
824 vol->source_rfc1001_name[15] = 0;
825 /* null target name indicates to use *SMBSERVR default called name
826 if we end up sending RFC1001 session initialize */
827 vol->target_rfc1001_name[0] = 0;
828 vol->linux_uid = current->uid; /* current->euid instead? */
829 vol->linux_gid = current->gid;
830 vol->dir_mode = S_IRWXUGO;
831 /* 2767 perms indicate mandatory locking support */
832 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
834 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
836 /* default is always to request posix paths. */
837 vol->posix_paths = 1;
842 if (strncmp(options, "sep=", 4) == 0) {
843 if (options[4] != 0) {
844 separator[0] = options[4];
847 cFYI(1, ("Null separator not allowed"));
851 while ((data = strsep(&options, separator)) != NULL) {
854 if ((value = strchr(data, '=')) != NULL)
857 /* Have to parse this before we parse for "user" */
858 if (strnicmp(data, "user_xattr", 10) == 0) {
860 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
862 } else if (strnicmp(data, "user", 4) == 0) {
865 "CIFS: invalid or missing username\n");
866 return 1; /* needs_arg; */
867 } else if (!*value) {
868 /* null user, ie anonymous, authentication */
871 if (strnlen(value, 200) < 200) {
872 vol->username = value;
874 printk(KERN_WARNING "CIFS: username too long\n");
877 } else if (strnicmp(data, "pass", 4) == 0) {
879 vol->password = NULL;
881 } else if (value[0] == 0) {
882 /* check if string begins with double comma
883 since that would mean the password really
884 does start with a comma, and would not
885 indicate an empty string */
886 if (value[1] != separator[0]) {
887 vol->password = NULL;
891 temp_len = strlen(value);
892 /* removed password length check, NTLM passwords
893 can be arbitrarily long */
895 /* if comma in password, the string will be
896 prematurely null terminated. Commas in password are
897 specified across the cifs mount interface by a double
898 comma ie ,, and a comma used as in other cases ie ','
899 as a parameter delimiter/separator is single and due
900 to the strsep above is temporarily zeroed. */
902 /* NB: password legally can have multiple commas and
903 the only illegal character in a password is null */
905 if ((value[temp_len] == 0) &&
906 (value[temp_len+1] == separator[0])) {
908 value[temp_len] = separator[0];
909 temp_len += 2; /* move after second comma */
910 while (value[temp_len] != 0) {
911 if (value[temp_len] == separator[0]) {
912 if (value[temp_len+1] ==
914 /* skip second comma */
917 /* single comma indicating start
924 if (value[temp_len] == 0) {
928 /* point option to start of next parm */
929 options = value + temp_len + 1;
931 /* go from value to value + temp_len condensing
932 double commas to singles. Note that this ends up
933 allocating a few bytes too many, which is ok */
934 vol->password = kzalloc(temp_len, GFP_KERNEL);
935 if (vol->password == NULL) {
936 printk(KERN_WARNING "CIFS: no memory "
940 for (i = 0, j = 0; i < temp_len; i++, j++) {
941 vol->password[j] = value[i];
942 if (value[i] == separator[0]
943 && value[i+1] == separator[0]) {
944 /* skip second comma */
948 vol->password[j] = 0;
950 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
951 if (vol->password == NULL) {
952 printk(KERN_WARNING "CIFS: no memory "
956 strcpy(vol->password, value);
958 } else if (strnicmp(data, "ip", 2) == 0) {
959 if (!value || !*value) {
961 } else if (strnlen(value, 35) < 35) {
964 printk(KERN_WARNING "CIFS: ip address "
968 } else if (strnicmp(data, "sec", 3) == 0) {
969 if (!value || !*value) {
970 cERROR(1, ("no security value specified"));
972 } else if (strnicmp(value, "krb5i", 5) == 0) {
973 vol->secFlg |= CIFSSEC_MAY_KRB5 |
975 } else if (strnicmp(value, "krb5p", 5) == 0) {
976 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
978 cERROR(1, ("Krb5 cifs privacy not supported"));
980 } else if (strnicmp(value, "krb5", 4) == 0) {
981 vol->secFlg |= CIFSSEC_MAY_KRB5;
982 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
983 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
985 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
986 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
987 } else if (strnicmp(value, "ntlmi", 5) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_NTLM |
990 } else if (strnicmp(value, "ntlm", 4) == 0) {
991 /* ntlm is default so can be turned off too */
992 vol->secFlg |= CIFSSEC_MAY_NTLM;
993 } else if (strnicmp(value, "nontlm", 6) == 0) {
994 /* BB is there a better way to do this? */
995 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
996 #ifdef CONFIG_CIFS_WEAK_PW_HASH
997 } else if (strnicmp(value, "lanman", 6) == 0) {
998 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1000 } else if (strnicmp(value, "none", 4) == 0) {
1003 cERROR(1, ("bad security option: %s", value));
1006 } else if ((strnicmp(data, "unc", 3) == 0)
1007 || (strnicmp(data, "target", 6) == 0)
1008 || (strnicmp(data, "path", 4) == 0)) {
1009 if (!value || !*value) {
1010 printk(KERN_WARNING "CIFS: invalid path to "
1011 "network resource\n");
1012 return 1; /* needs_arg; */
1014 if ((temp_len = strnlen(value, 300)) < 300) {
1015 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1016 if (vol->UNC == NULL)
1018 strcpy(vol->UNC, value);
1019 if (strncmp(vol->UNC, "//", 2) == 0) {
1022 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1024 "CIFS: UNC Path does not begin "
1025 "with // or \\\\ \n");
1029 printk(KERN_WARNING "CIFS: UNC name too long\n");
1032 } else if ((strnicmp(data, "domain", 3) == 0)
1033 || (strnicmp(data, "workgroup", 5) == 0)) {
1034 if (!value || !*value) {
1035 printk(KERN_WARNING "CIFS: invalid domain name\n");
1036 return 1; /* needs_arg; */
1038 /* BB are there cases in which a comma can be valid in
1039 a domain name and need special handling? */
1040 if (strnlen(value, 256) < 256) {
1041 vol->domainname = value;
1042 cFYI(1, ("Domain name set"));
1044 printk(KERN_WARNING "CIFS: domain name too "
1048 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1049 if (!value || !*value) {
1051 "CIFS: invalid path prefix\n");
1052 return 1; /* needs_argument */
1054 if ((temp_len = strnlen(value, 1024)) < 1024) {
1055 if (value[0] != '/')
1056 temp_len++; /* missing leading slash */
1057 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1058 if (vol->prepath == NULL)
1060 if (value[0] != '/') {
1061 vol->prepath[0] = '/';
1062 strcpy(vol->prepath+1, value);
1064 strcpy(vol->prepath, value);
1065 cFYI(1, ("prefix path %s", vol->prepath));
1067 printk(KERN_WARNING "CIFS: prefix too long\n");
1070 } else if (strnicmp(data, "iocharset", 9) == 0) {
1071 if (!value || !*value) {
1072 printk(KERN_WARNING "CIFS: invalid iocharset "
1074 return 1; /* needs_arg; */
1076 if (strnlen(value, 65) < 65) {
1077 if (strnicmp(value, "default", 7))
1078 vol->iocharset = value;
1079 /* if iocharset not set then load_nls_default
1080 is used by caller */
1081 cFYI(1, ("iocharset set to %s", value));
1083 printk(KERN_WARNING "CIFS: iocharset name "
1087 } else if (strnicmp(data, "uid", 3) == 0) {
1088 if (value && *value) {
1090 simple_strtoul(value, &value, 0);
1091 vol->override_uid = 1;
1093 } else if (strnicmp(data, "gid", 3) == 0) {
1094 if (value && *value) {
1096 simple_strtoul(value, &value, 0);
1097 vol->override_gid = 1;
1099 } else if (strnicmp(data, "file_mode", 4) == 0) {
1100 if (value && *value) {
1102 simple_strtoul(value, &value, 0);
1104 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1105 if (value && *value) {
1107 simple_strtoul(value, &value, 0);
1109 } else if (strnicmp(data, "dirmode", 4) == 0) {
1110 if (value && *value) {
1112 simple_strtoul(value, &value, 0);
1114 } else if (strnicmp(data, "port", 4) == 0) {
1115 if (value && *value) {
1117 simple_strtoul(value, &value, 0);
1119 } else if (strnicmp(data, "rsize", 5) == 0) {
1120 if (value && *value) {
1122 simple_strtoul(value, &value, 0);
1124 } else if (strnicmp(data, "wsize", 5) == 0) {
1125 if (value && *value) {
1127 simple_strtoul(value, &value, 0);
1129 } else if (strnicmp(data, "sockopt", 5) == 0) {
1130 if (value && *value) {
1132 simple_strtoul(value, &value, 0);
1134 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1135 if (!value || !*value || (*value == ' ')) {
1136 cFYI(1, ("invalid (empty) netbiosname"));
1138 memset(vol->source_rfc1001_name, 0x20, 15);
1139 for (i = 0; i < 15; i++) {
1140 /* BB are there cases in which a comma can be
1141 valid in this workstation netbios name (and need
1142 special handling)? */
1144 /* We do not uppercase netbiosname for user */
1148 vol->source_rfc1001_name[i] =
1151 /* The string has 16th byte zero still from
1152 set at top of the function */
1153 if ((i == 15) && (value[i] != 0))
1154 printk(KERN_WARNING "CIFS: netbiosname"
1155 " longer than 15 truncated.\n");
1157 } else if (strnicmp(data, "servern", 7) == 0) {
1158 /* servernetbiosname specified override *SMBSERVER */
1159 if (!value || !*value || (*value == ' ')) {
1160 cFYI(1, ("empty server netbiosname specified"));
1162 /* last byte, type, is 0x20 for servr type */
1163 memset(vol->target_rfc1001_name, 0x20, 16);
1165 for (i = 0; i < 15; i++) {
1166 /* BB are there cases in which a comma can be
1167 valid in this workstation netbios name
1168 (and need special handling)? */
1170 /* user or mount helper must uppercase
1175 vol->target_rfc1001_name[i] =
1178 /* The string has 16th byte zero still from
1179 set at top of the function */
1180 if ((i == 15) && (value[i] != 0))
1181 printk(KERN_WARNING "CIFS: server net"
1182 "biosname longer than 15 truncated.\n");
1184 } else if (strnicmp(data, "credentials", 4) == 0) {
1186 } else if (strnicmp(data, "version", 3) == 0) {
1188 } else if (strnicmp(data, "guest", 5) == 0) {
1190 } else if (strnicmp(data, "rw", 2) == 0) {
1192 } else if ((strnicmp(data, "suid", 4) == 0) ||
1193 (strnicmp(data, "nosuid", 6) == 0) ||
1194 (strnicmp(data, "exec", 4) == 0) ||
1195 (strnicmp(data, "noexec", 6) == 0) ||
1196 (strnicmp(data, "nodev", 5) == 0) ||
1197 (strnicmp(data, "noauto", 6) == 0) ||
1198 (strnicmp(data, "dev", 3) == 0)) {
1199 /* The mount tool or mount.cifs helper (if present)
1200 uses these opts to set flags, and the flags are read
1201 by the kernel vfs layer before we get here (ie
1202 before read super) so there is no point trying to
1203 parse these options again and set anything and it
1204 is ok to just ignore them */
1206 } else if (strnicmp(data, "ro", 2) == 0) {
1208 } else if (strnicmp(data, "hard", 4) == 0) {
1210 } else if (strnicmp(data, "soft", 4) == 0) {
1212 } else if (strnicmp(data, "perm", 4) == 0) {
1214 } else if (strnicmp(data, "noperm", 6) == 0) {
1216 } else if (strnicmp(data, "mapchars", 8) == 0) {
1218 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1220 } else if (strnicmp(data, "sfu", 3) == 0) {
1222 } else if (strnicmp(data, "nosfu", 5) == 0) {
1224 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1225 vol->posix_paths = 1;
1226 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1227 vol->posix_paths = 0;
1228 } else if (strnicmp(data, "nounix", 6) == 0) {
1229 vol->no_linux_ext = 1;
1230 } else if (strnicmp(data, "nolinux", 7) == 0) {
1231 vol->no_linux_ext = 1;
1232 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1233 (strnicmp(data, "ignorecase", 10) == 0)) {
1235 } else if (strnicmp(data, "brl", 3) == 0) {
1237 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1238 (strnicmp(data, "nolock", 6) == 0)) {
1240 /* turn off mandatory locking in mode
1241 if remote locking is turned off since the
1242 local vfs will do advisory */
1243 if (vol->file_mode ==
1244 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1245 vol->file_mode = S_IALLUGO;
1246 } else if (strnicmp(data, "setuids", 7) == 0) {
1248 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1250 } else if (strnicmp(data, "dynperm", 7) == 0) {
1251 vol->dynperm = true;
1252 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1253 vol->dynperm = false;
1254 } else if (strnicmp(data, "nohard", 6) == 0) {
1256 } else if (strnicmp(data, "nosoft", 6) == 0) {
1258 } else if (strnicmp(data, "nointr", 6) == 0) {
1260 } else if (strnicmp(data, "intr", 4) == 0) {
1262 } else if (strnicmp(data, "serverino", 7) == 0) {
1263 vol->server_ino = 1;
1264 } else if (strnicmp(data, "noserverino", 9) == 0) {
1265 vol->server_ino = 0;
1266 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1268 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1270 } else if (strnicmp(data, "acl", 3) == 0) {
1271 vol->no_psx_acl = 0;
1272 } else if (strnicmp(data, "noacl", 5) == 0) {
1273 vol->no_psx_acl = 1;
1274 } else if (strnicmp(data, "sign", 4) == 0) {
1275 vol->secFlg |= CIFSSEC_MUST_SIGN;
1276 /* } else if (strnicmp(data, "seal",4) == 0) {
1277 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1278 } else if (strnicmp(data, "direct", 6) == 0) {
1280 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1282 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1283 if (!value || !*value) {
1284 vol->in6_addr = NULL;
1285 } else if (strnlen(value, 49) == 48) {
1286 vol->in6_addr = value;
1288 printk(KERN_WARNING "CIFS: ip v6 address not "
1289 "48 characters long\n");
1292 } else if (strnicmp(data, "noac", 4) == 0) {
1293 printk(KERN_WARNING "CIFS: Mount option noac not "
1294 "supported. Instead set "
1295 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1297 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1300 if (vol->UNC == NULL) {
1301 if (devname == NULL) {
1302 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1306 if ((temp_len = strnlen(devname, 300)) < 300) {
1307 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1308 if (vol->UNC == NULL)
1310 strcpy(vol->UNC, devname);
1311 if (strncmp(vol->UNC, "//", 2) == 0) {
1314 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1315 printk(KERN_WARNING "CIFS: UNC Path does not "
1316 "begin with // or \\\\ \n");
1319 value = strpbrk(vol->UNC+2, "/\\");
1323 printk(KERN_WARNING "CIFS: UNC name too long\n");
1327 if (vol->UNCip == NULL)
1328 vol->UNCip = &vol->UNC[2];
1333 static struct cifsSesInfo *
1334 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1335 struct in6_addr *target_ip6_addr,
1336 char *userName, struct TCP_Server_Info **psrvTcp)
1338 struct list_head *tmp;
1339 struct cifsSesInfo *ses;
1343 read_lock(&GlobalSMBSeslock);
1344 list_for_each(tmp, &GlobalSMBSessionList) {
1345 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1349 if (target_ip_addr &&
1350 ses->server->addr.sockAddr.sin_addr.s_addr != target_ip_addr->s_addr)
1352 else if (target_ip6_addr &&
1353 memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1354 target_ip6_addr, sizeof(*target_ip6_addr)))
1356 /* BB lock server and tcp session; increment use count here?? */
1358 /* found a match on the TCP session */
1359 *psrvTcp = ses->server;
1361 /* BB check if reconnection needed */
1362 if (strncmp(ses->userName, userName, MAX_USERNAME_SIZE) == 0) {
1363 read_unlock(&GlobalSMBSeslock);
1364 /* Found exact match on both TCP and
1368 /* else tcp and smb sessions need reconnection */
1370 read_unlock(&GlobalSMBSeslock);
1375 static struct cifsTconInfo *
1376 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1378 struct list_head *tmp;
1379 struct cifsTconInfo *tcon;
1382 read_lock(&GlobalSMBSeslock);
1384 list_for_each(tmp, &GlobalTreeConnectionList) {
1385 cFYI(1, ("Next tcon"));
1386 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1387 if (!tcon->ses || !tcon->ses->server)
1390 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1391 cFYI(1, ("old ip addr: %x == new ip %x ?",
1392 old_ip, new_target_ip_addr));
1394 if (old_ip != new_target_ip_addr)
1397 /* BB lock tcon, server, tcp session and increment use count? */
1398 /* found a match on the TCP session */
1399 /* BB check if reconnection needed */
1400 cFYI(1, ("IP match, old UNC: %s new: %s",
1401 tcon->treeName, uncName));
1403 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1406 cFYI(1, ("and old usr: %s new: %s",
1407 tcon->treeName, uncName));
1409 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1412 /* matched smb session (user name) */
1413 read_unlock(&GlobalSMBSeslock);
1417 read_unlock(&GlobalSMBSeslock);
1422 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1423 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1424 struct dfs_info3_param **preferrals, int remap)
1428 unsigned char *targetUNCs;
1430 *pnum_referrals = 0;
1433 if (pSesInfo->ipc_tid == 0) {
1434 temp_unc = kmalloc(2 /* for slashes */ +
1435 strnlen(pSesInfo->serverName,
1436 SERVER_NAME_LEN_WITH_NULL * 2)
1437 + 1 + 4 /* slash IPC$ */ + 2,
1439 if (temp_unc == NULL)
1443 strcpy(temp_unc + 2, pSesInfo->serverName);
1444 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1445 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1447 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1451 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
1452 pnum_referrals, nls_codepage, remap);
1453 /* BB map targetUNCs to dfs_info3 structures, here or
1454 in CIFSGetDFSRefer BB */
1459 /* See RFC1001 section 14 on representation of Netbios names */
1460 static void rfc1002mangle(char *target, char *source, unsigned int length)
1464 for (i = 0, j = 0; i < (length); i++) {
1465 /* mask a nibble at a time and encode */
1466 target[j] = 'A' + (0x0F & (source[i] >> 4));
1467 target[j+1] = 'A' + (0x0F & source[i]);
1475 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1476 char *netbios_name, char *target_name)
1480 __be16 orig_port = 0;
1482 if (*csocket == NULL) {
1483 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1484 IPPROTO_TCP, csocket);
1486 cERROR(1, ("Error %d creating socket", rc));
1490 /* BB other socket options to set KEEPALIVE, NODELAY? */
1491 cFYI(1, ("Socket created"));
1492 (*csocket)->sk->sk_allocation = GFP_NOFS;
1496 psin_server->sin_family = AF_INET;
1497 if (psin_server->sin_port) { /* user overrode default port */
1498 rc = (*csocket)->ops->connect(*csocket,
1499 (struct sockaddr *) psin_server,
1500 sizeof(struct sockaddr_in), 0);
1506 /* save original port so we can retry user specified port
1507 later if fall back ports fail this time */
1508 orig_port = psin_server->sin_port;
1510 /* do not retry on the same port we just failed on */
1511 if (psin_server->sin_port != htons(CIFS_PORT)) {
1512 psin_server->sin_port = htons(CIFS_PORT);
1514 rc = (*csocket)->ops->connect(*csocket,
1515 (struct sockaddr *) psin_server,
1516 sizeof(struct sockaddr_in), 0);
1522 psin_server->sin_port = htons(RFC1001_PORT);
1523 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1525 sizeof(struct sockaddr_in), 0);
1530 /* give up here - unless we want to retry on different
1531 protocol families some day */
1534 psin_server->sin_port = orig_port;
1535 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1536 sock_release(*csocket);
1540 /* Eventually check for other socket options to change from
1541 the default. sock_setsockopt not used because it expects
1542 user space buffer */
1543 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1544 (*csocket)->sk->sk_sndbuf,
1545 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1546 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1547 /* make the bufsizes depend on wsize/rsize and max requests */
1548 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1549 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1550 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1551 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1553 /* send RFC1001 sessinit */
1554 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1555 /* some servers require RFC1001 sessinit before sending
1556 negprot - BB check reconnection in case where second
1557 sessinit is sent but no second negprot */
1558 struct rfc1002_session_packet *ses_init_buf;
1559 struct smb_hdr *smb_buf;
1560 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1563 ses_init_buf->trailer.session_req.called_len = 32;
1564 if (target_name && (target_name[0] != 0)) {
1565 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1568 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1569 DEFAULT_CIFS_CALLED_NAME, 16);
1572 ses_init_buf->trailer.session_req.calling_len = 32;
1573 /* calling name ends in null (byte 16) from old smb
1575 if (netbios_name && (netbios_name[0] != 0)) {
1576 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1579 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1580 "LINUX_CIFS_CLNT", 16);
1582 ses_init_buf->trailer.session_req.scope1 = 0;
1583 ses_init_buf->trailer.session_req.scope2 = 0;
1584 smb_buf = (struct smb_hdr *)ses_init_buf;
1585 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1586 smb_buf->smb_buf_length = 0x81000044;
1587 rc = smb_send(*csocket, smb_buf, 0x44,
1588 (struct sockaddr *)psin_server);
1589 kfree(ses_init_buf);
1590 msleep(1); /* RFC1001 layer in at least one server
1591 requires very short break before negprot
1592 presumably because not expecting negprot
1593 to follow so fast. This is a simple
1594 solution that works without
1595 complicating the code and causes no
1596 significant slowing down on mount
1597 for everyone else */
1599 /* else the negprot may still work without this
1600 even though malloc failed */
1608 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1612 __be16 orig_port = 0;
1614 if (*csocket == NULL) {
1615 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1616 IPPROTO_TCP, csocket);
1618 cERROR(1, ("Error %d creating ipv6 socket", rc));
1622 /* BB other socket options to set KEEPALIVE, NODELAY? */
1623 cFYI(1, ("ipv6 Socket created"));
1624 (*csocket)->sk->sk_allocation = GFP_NOFS;
1628 psin_server->sin6_family = AF_INET6;
1630 if (psin_server->sin6_port) { /* user overrode default port */
1631 rc = (*csocket)->ops->connect(*csocket,
1632 (struct sockaddr *) psin_server,
1633 sizeof(struct sockaddr_in6), 0);
1639 /* save original port so we can retry user specified port
1640 later if fall back ports fail this time */
1642 orig_port = psin_server->sin6_port;
1643 /* do not retry on the same port we just failed on */
1644 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1645 psin_server->sin6_port = htons(CIFS_PORT);
1647 rc = (*csocket)->ops->connect(*csocket,
1648 (struct sockaddr *) psin_server,
1649 sizeof(struct sockaddr_in6), 0);
1655 psin_server->sin6_port = htons(RFC1001_PORT);
1656 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1657 psin_server, sizeof(struct sockaddr_in6), 0);
1662 /* give up here - unless we want to retry on different
1663 protocol families some day */
1666 psin_server->sin6_port = orig_port;
1667 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1668 sock_release(*csocket);
1672 /* Eventually check for other socket options to change from
1673 the default. sock_setsockopt not used because it expects
1674 user space buffer */
1675 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1680 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1681 struct super_block *sb, struct smb_vol *vol_info)
1683 /* if we are reconnecting then should we check to see if
1684 * any requested capabilities changed locally e.g. via
1685 * remount but we can not do much about it here
1686 * if they have (even if we could detect it by the following)
1687 * Perhaps we could add a backpointer to array of sb from tcon
1688 * or if we change to make all sb to same share the same
1689 * sb as NFS - then we only have one backpointer to sb.
1690 * What if we wanted to mount the server share twice once with
1691 * and once without posixacls or posix paths? */
1692 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1694 if (vol_info && vol_info->no_linux_ext) {
1695 tcon->fsUnixInfo.Capability = 0;
1696 tcon->unix_ext = 0; /* Unix Extensions disabled */
1697 cFYI(1, ("Linux protocol extensions disabled"));
1699 } else if (vol_info)
1700 tcon->unix_ext = 1; /* Unix Extensions supported */
1702 if (tcon->unix_ext == 0) {
1703 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1707 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1708 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1710 /* check for reconnect case in which we do not
1711 want to change the mount behavior if we can avoid it */
1712 if (vol_info == NULL) {
1713 /* turn off POSIX ACL and PATHNAMES if not set
1714 originally at mount time */
1715 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1716 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1717 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1718 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1719 cERROR(1, ("POSIXPATH support change"));
1720 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1721 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1722 cERROR(1, ("possible reconnect error"));
1724 ("server disabled POSIX path support"));
1728 cap &= CIFS_UNIX_CAP_MASK;
1729 if (vol_info && vol_info->no_psx_acl)
1730 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1731 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1732 cFYI(1, ("negotiated posix acl support"));
1734 sb->s_flags |= MS_POSIXACL;
1737 if (vol_info && vol_info->posix_paths == 0)
1738 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1739 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1740 cFYI(1, ("negotiate posix pathnames"));
1742 CIFS_SB(sb)->mnt_cifs_flags |=
1743 CIFS_MOUNT_POSIX_PATHS;
1746 /* We might be setting the path sep back to a different
1747 form if we are reconnecting and the server switched its
1748 posix path capability for this share */
1749 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1750 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1752 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1753 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1754 CIFS_SB(sb)->rsize = 127 * 1024;
1756 ("larger reads not supported by srv"));
1761 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1762 #ifdef CONFIG_CIFS_DEBUG2
1763 if (cap & CIFS_UNIX_FCNTL_CAP)
1764 cFYI(1, ("FCNTL cap"));
1765 if (cap & CIFS_UNIX_EXTATTR_CAP)
1766 cFYI(1, ("EXTATTR cap"));
1767 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1768 cFYI(1, ("POSIX path cap"));
1769 if (cap & CIFS_UNIX_XATTR_CAP)
1770 cFYI(1, ("XATTR cap"));
1771 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1772 cFYI(1, ("POSIX ACL cap"));
1773 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1774 cFYI(1, ("very large read cap"));
1775 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1776 cFYI(1, ("very large write cap"));
1777 #endif /* CIFS_DEBUG2 */
1778 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1779 if (vol_info == NULL) {
1780 cFYI(1, ("resetting capabilities failed"));
1782 cERROR(1, ("Negotiating Unix capabilities "
1783 "with the server failed. Consider "
1784 "mounting with the Unix Extensions\n"
1785 "disabled, if problems are found, "
1786 "by specifying the nounix mount "
1794 convert_delimiter(char *path, char delim)
1807 for (i = 0; path[i] != '\0'; i++) {
1808 if (path[i] == old_delim)
1814 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1815 char *mount_data, const char *devname)
1819 int address_type = AF_INET;
1820 struct socket *csocket = NULL;
1821 struct sockaddr_in sin_server;
1822 struct sockaddr_in6 sin_server6;
1823 struct smb_vol volume_info;
1824 struct cifsSesInfo *pSesInfo = NULL;
1825 struct cifsSesInfo *existingCifsSes = NULL;
1826 struct cifsTconInfo *tcon = NULL;
1827 struct TCP_Server_Info *srvTcp = NULL;
1831 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1833 memset(&volume_info, 0, sizeof(struct smb_vol));
1834 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1839 if (volume_info.nullauth) {
1840 cFYI(1, ("null user"));
1841 volume_info.username = "";
1842 } else if (volume_info.username) {
1843 /* BB fixme parse for domain name here */
1844 cFYI(1, ("Username: %s", volume_info.username));
1846 cifserror("No username specified");
1847 /* In userspace mount helper we can get user name from alternate
1848 locations such as env variables and files on disk */
1853 if (volume_info.UNCip && volume_info.UNC) {
1854 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1855 &sin_server.sin_addr.s_addr);
1858 /* not ipv4 address, try ipv6 */
1859 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1860 &sin_server6.sin6_addr.in6_u);
1862 address_type = AF_INET6;
1864 address_type = AF_INET;
1868 /* we failed translating address */
1873 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1876 } else if (volume_info.UNCip) {
1877 /* BB using ip addr as server name to connect to the
1879 cERROR(1, ("Connecting to DFS root not implemented yet"));
1882 } else /* which servers DFS root would we conect to */ {
1884 ("CIFS mount error: No UNC path (e.g. -o "
1885 "unc=//192.168.1.100/public) specified"));
1890 /* this is needed for ASCII cp to Unicode converts */
1891 if (volume_info.iocharset == NULL) {
1892 cifs_sb->local_nls = load_nls_default();
1893 /* load_nls_default can not return null */
1895 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1896 if (cifs_sb->local_nls == NULL) {
1897 cERROR(1, ("CIFS mount error: iocharset %s not found",
1898 volume_info.iocharset));
1904 if (address_type == AF_INET)
1905 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1906 NULL /* no ipv6 addr */,
1907 volume_info.username, &srvTcp);
1908 else if (address_type == AF_INET6) {
1909 cFYI(1, ("looking for ipv6 address"));
1910 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1911 &sin_server6.sin6_addr,
1912 volume_info.username, &srvTcp);
1919 cFYI(1, ("Existing tcp session with server found"));
1920 } else { /* create socket */
1921 if (volume_info.port)
1922 sin_server.sin_port = htons(volume_info.port);
1924 sin_server.sin_port = 0;
1925 if (address_type == AF_INET6) {
1926 cFYI(1, ("attempting ipv6 connect"));
1927 /* BB should we allow ipv6 on port 139? */
1928 /* other OS never observed in Wild doing 139 with v6 */
1929 rc = ipv6_connect(&sin_server6, &csocket);
1931 rc = ipv4_connect(&sin_server, &csocket,
1932 volume_info.source_rfc1001_name,
1933 volume_info.target_rfc1001_name);
1935 cERROR(1, ("Error connecting to IPv4 socket. "
1936 "Aborting operation"));
1937 if (csocket != NULL)
1938 sock_release(csocket);
1942 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1945 sock_release(csocket);
1948 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1949 sizeof(struct sockaddr_in));
1950 atomic_set(&srvTcp->inFlight, 0);
1951 /* BB Add code for ipv6 case too */
1952 srvTcp->ssocket = csocket;
1953 srvTcp->protocolType = IPV4;
1954 srvTcp->hostname = extract_hostname(volume_info.UNC);
1955 if (IS_ERR(srvTcp->hostname)) {
1956 rc = PTR_ERR(srvTcp->hostname);
1957 sock_release(csocket);
1960 init_waitqueue_head(&srvTcp->response_q);
1961 init_waitqueue_head(&srvTcp->request_q);
1962 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1963 /* at this point we are the only ones with the pointer
1964 to the struct since the kernel thread not created yet
1965 so no need to spinlock this init of tcpStatus */
1966 srvTcp->tcpStatus = CifsNew;
1967 init_MUTEX(&srvTcp->tcpSem);
1968 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1969 if (IS_ERR(srvTcp->tsk)) {
1970 rc = PTR_ERR(srvTcp->tsk);
1971 cERROR(1, ("error %d create cifsd thread", rc));
1973 sock_release(csocket);
1974 kfree(srvTcp->hostname);
1978 memcpy(srvTcp->workstation_RFC1001_name,
1979 volume_info.source_rfc1001_name, 16);
1980 memcpy(srvTcp->server_RFC1001_name,
1981 volume_info.target_rfc1001_name, 16);
1982 srvTcp->sequence_number = 0;
1986 if (existingCifsSes) {
1987 pSesInfo = existingCifsSes;
1988 cFYI(1, ("Existing smb sess found (status=%d)",
1990 down(&pSesInfo->sesSem);
1991 if (pSesInfo->status == CifsNeedReconnect) {
1992 cFYI(1, ("Session needs reconnect"));
1993 rc = cifs_setup_session(xid, pSesInfo,
1994 cifs_sb->local_nls);
1996 up(&pSesInfo->sesSem);
1998 cFYI(1, ("Existing smb sess not found"));
1999 pSesInfo = sesInfoAlloc();
2000 if (pSesInfo == NULL)
2003 pSesInfo->server = srvTcp;
2004 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2005 NIPQUAD(sin_server.sin_addr.s_addr));
2009 /* volume_info.password freed at unmount */
2010 if (volume_info.password) {
2011 pSesInfo->password = volume_info.password;
2012 /* set to NULL to prevent freeing on exit */
2013 volume_info.password = NULL;
2015 if (volume_info.username)
2016 strncpy(pSesInfo->userName,
2017 volume_info.username,
2019 if (volume_info.domainname) {
2020 int len = strlen(volume_info.domainname);
2021 pSesInfo->domainName =
2022 kmalloc(len + 1, GFP_KERNEL);
2023 if (pSesInfo->domainName)
2024 strcpy(pSesInfo->domainName,
2025 volume_info.domainname);
2027 pSesInfo->linux_uid = volume_info.linux_uid;
2028 pSesInfo->overrideSecFlg = volume_info.secFlg;
2029 down(&pSesInfo->sesSem);
2030 /* BB FIXME need to pass vol->secFlgs BB */
2031 rc = cifs_setup_session(xid, pSesInfo,
2032 cifs_sb->local_nls);
2033 up(&pSesInfo->sesSem);
2035 atomic_inc(&srvTcp->socketUseCount);
2039 /* search for existing tcon to this server share */
2041 if (volume_info.rsize > CIFSMaxBufSize) {
2042 cERROR(1, ("rsize %d too large, using MaxBufSize",
2043 volume_info.rsize));
2044 cifs_sb->rsize = CIFSMaxBufSize;
2045 } else if ((volume_info.rsize) &&
2046 (volume_info.rsize <= CIFSMaxBufSize))
2047 cifs_sb->rsize = volume_info.rsize;
2049 cifs_sb->rsize = CIFSMaxBufSize;
2051 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2052 cERROR(1, ("wsize %d too large, using 4096 instead",
2053 volume_info.wsize));
2054 cifs_sb->wsize = 4096;
2055 } else if (volume_info.wsize)
2056 cifs_sb->wsize = volume_info.wsize;
2059 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2061 /* old default of CIFSMaxBufSize was too small now
2062 that SMB Write2 can send multiple pages in kvec.
2063 RFC1001 does not describe what happens when frame
2064 bigger than 128K is sent so use that as max in
2065 conjunction with 52K kvec constraint on arch with 4K
2068 if (cifs_sb->rsize < 2048) {
2069 cifs_sb->rsize = 2048;
2070 /* Windows ME may prefer this */
2071 cFYI(1, ("readsize set to minimum: 2048"));
2073 /* calculate prepath */
2074 cifs_sb->prepath = volume_info.prepath;
2075 if (cifs_sb->prepath) {
2076 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2077 /* we can not convert the / to \ in the path
2078 separators in the prefixpath yet because we do not
2079 know (until reset_cifs_unix_caps is called later)
2080 whether POSIX PATH CAP is available. We normalize
2081 the / to \ after reset_cifs_unix_caps is called */
2082 volume_info.prepath = NULL;
2084 cifs_sb->prepathlen = 0;
2085 cifs_sb->mnt_uid = volume_info.linux_uid;
2086 cifs_sb->mnt_gid = volume_info.linux_gid;
2087 cifs_sb->mnt_file_mode = volume_info.file_mode;
2088 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2089 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2090 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2092 if (volume_info.noperm)
2093 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2094 if (volume_info.setuids)
2095 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2096 if (volume_info.server_ino)
2097 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2098 if (volume_info.remap)
2099 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2100 if (volume_info.no_xattr)
2101 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2102 if (volume_info.sfu_emul)
2103 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2104 if (volume_info.nobrl)
2105 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2106 if (volume_info.cifs_acl)
2107 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2108 if (volume_info.override_uid)
2109 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2110 if (volume_info.override_gid)
2111 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2112 if (volume_info.dynperm)
2113 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2114 if (volume_info.direct_io) {
2115 cFYI(1, ("mounting share using direct i/o"));
2116 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2120 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2121 volume_info.username);
2123 cFYI(1, ("Found match on UNC path"));
2124 /* we can have only one retry value for a connection
2125 to a share so for resources mounted more than once
2126 to the same server share the last value passed in
2127 for the retry flag is used */
2128 tcon->retry = volume_info.retry;
2129 tcon->nocase = volume_info.nocase;
2131 tcon = tconInfoAlloc();
2135 /* check for null share name ie connecting to
2138 /* BB check if this works for exactly length
2140 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2141 && (strchr(volume_info.UNC + 3, '/') ==
2143 /* rc = connect_to_dfs_path(xid, pSesInfo,
2144 "", cifs_sb->local_nls,
2145 cifs_sb->mnt_cifs_flags &
2146 CIFS_MOUNT_MAP_SPECIAL_CHR);*/
2147 cFYI(1, ("DFS root not supported"));
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 /* If we could verify that kthread_stop would
2187 always wake up processes blocked in
2188 tcp in recv_mesg then we could remove the
2190 force_sig(SIGKILL, srvTcp->tsk);
2191 kthread_stop(srvTcp->tsk);
2194 /* If find_unc succeeded then rc == 0 so we can not end */
2195 if (tcon) /* up accidently freeing someone elses tcon struct */
2197 if (existingCifsSes == NULL) {
2199 if ((pSesInfo->server) &&
2200 (pSesInfo->status == CifsGood)) {
2202 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2203 /* if the socketUseCount is now zero */
2204 if ((temp_rc == -ESHUTDOWN) &&
2205 (pSesInfo->server) &&
2206 (pSesInfo->server->tsk)) {
2208 pSesInfo->server->tsk);
2209 kthread_stop(pSesInfo->server->tsk);
2212 cFYI(1, ("No session or bad tcon"));
2213 if ((pSesInfo->server) &&
2214 (pSesInfo->server->tsk)) {
2216 pSesInfo->server->tsk);
2217 kthread_stop(pSesInfo->server->tsk);
2220 sesInfoFree(pSesInfo);
2221 /* pSesInfo = NULL; */
2225 atomic_inc(&tcon->useCount);
2226 cifs_sb->tcon = tcon;
2227 tcon->ses = pSesInfo;
2229 /* do not care if following two calls succeed - informational */
2231 CIFSSMBQFSDeviceInfo(xid, tcon);
2232 CIFSSMBQFSAttributeInfo(xid, tcon);
2235 /* tell server which Unix caps we support */
2236 if (tcon->ses->capabilities & CAP_UNIX)
2237 /* reset of caps checks mount to see if unix extensions
2238 disabled for just this mount */
2239 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2241 tcon->unix_ext = 0; /* server does not support them */
2243 /* convert forward to back slashes in prepath here if needed */
2244 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2245 convert_delimiter(cifs_sb->prepath,
2246 CIFS_DIR_SEP(cifs_sb));
2248 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2249 cifs_sb->rsize = 1024 * 127;
2251 ("no very large read support, rsize now 127K"));
2253 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2254 cifs_sb->wsize = min(cifs_sb->wsize,
2255 (tcon->ses->server->maxBuf -
2256 MAX_CIFS_HDR_SIZE));
2257 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2258 cifs_sb->rsize = min(cifs_sb->rsize,
2259 (tcon->ses->server->maxBuf -
2260 MAX_CIFS_HDR_SIZE));
2263 /* volume_info.password is freed above when existing session found
2264 (in which case it is not needed anymore) but when new sesion is created
2265 the password ptr is put in the new session structure (in which case the
2266 password will be freed at unmount time) */
2268 /* zero out password before freeing */
2269 if (volume_info.password != NULL) {
2270 memset(volume_info.password, 0, strlen(volume_info.password));
2271 kfree(volume_info.password);
2273 kfree(volume_info.UNC);
2274 kfree(volume_info.prepath);
2280 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2281 char session_key[CIFS_SESS_KEY_SIZE],
2282 const struct nls_table *nls_codepage)
2284 struct smb_hdr *smb_buffer;
2285 struct smb_hdr *smb_buffer_response;
2286 SESSION_SETUP_ANDX *pSMB;
2287 SESSION_SETUP_ANDX *pSMBr;
2292 int remaining_words = 0;
2293 int bytes_returned = 0;
2298 cFYI(1, ("In sesssetup"));
2301 user = ses->userName;
2302 domain = ses->domainName;
2303 smb_buffer = cifs_buf_get();
2305 if (smb_buffer == NULL)
2308 smb_buffer_response = smb_buffer;
2309 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2311 /* send SMBsessionSetup here */
2312 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2313 NULL /* no tCon exists yet */ , 13 /* wct */ );
2315 smb_buffer->Mid = GetNextMid(ses->server);
2316 pSMB->req_no_secext.AndXCommand = 0xFF;
2317 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2318 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2320 if (ses->server->secMode &
2321 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2322 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2324 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2325 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2326 if (ses->capabilities & CAP_UNICODE) {
2327 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2328 capabilities |= CAP_UNICODE;
2330 if (ses->capabilities & CAP_STATUS32) {
2331 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2332 capabilities |= CAP_STATUS32;
2334 if (ses->capabilities & CAP_DFS) {
2335 smb_buffer->Flags2 |= SMBFLG2_DFS;
2336 capabilities |= CAP_DFS;
2338 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2340 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2341 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2343 pSMB->req_no_secext.CaseSensitivePasswordLength =
2344 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2345 bcc_ptr = pByteArea(smb_buffer);
2346 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2347 bcc_ptr += CIFS_SESS_KEY_SIZE;
2348 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2349 bcc_ptr += CIFS_SESS_KEY_SIZE;
2351 if (ses->capabilities & CAP_UNICODE) {
2352 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2357 bytes_returned = 0; /* skip null user */
2360 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2362 /* convert number of 16 bit words to bytes */
2363 bcc_ptr += 2 * bytes_returned;
2364 bcc_ptr += 2; /* trailing null */
2367 cifs_strtoUCS((__le16 *) bcc_ptr,
2368 "CIFS_LINUX_DOM", 32, nls_codepage);
2371 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2373 bcc_ptr += 2 * bytes_returned;
2376 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2378 bcc_ptr += 2 * bytes_returned;
2380 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2382 bcc_ptr += 2 * bytes_returned;
2385 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2387 bcc_ptr += 2 * bytes_returned;
2391 strncpy(bcc_ptr, user, 200);
2392 bcc_ptr += strnlen(user, 200);
2396 if (domain == NULL) {
2397 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2398 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2400 strncpy(bcc_ptr, domain, 64);
2401 bcc_ptr += strnlen(domain, 64);
2405 strcpy(bcc_ptr, "Linux version ");
2406 bcc_ptr += strlen("Linux version ");
2407 strcpy(bcc_ptr, utsname()->release);
2408 bcc_ptr += strlen(utsname()->release) + 1;
2409 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2410 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2412 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2413 smb_buffer->smb_buf_length += count;
2414 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2416 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2417 &bytes_returned, CIFS_LONG_OP);
2419 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2420 } else if ((smb_buffer_response->WordCount == 3)
2421 || (smb_buffer_response->WordCount == 4)) {
2422 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2423 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2424 if (action & GUEST_LOGIN)
2425 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2426 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2428 cFYI(1, ("UID = %d ", ses->Suid));
2429 /* response can have either 3 or 4 word count - Samba sends 3 */
2430 bcc_ptr = pByteArea(smb_buffer_response);
2431 if ((pSMBr->resp.hdr.WordCount == 3)
2432 || ((pSMBr->resp.hdr.WordCount == 4)
2433 && (blob_len < pSMBr->resp.ByteCount))) {
2434 if (pSMBr->resp.hdr.WordCount == 4)
2435 bcc_ptr += blob_len;
2437 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2438 if ((long) (bcc_ptr) % 2) {
2440 (BCC(smb_buffer_response) - 1) / 2;
2441 /* Unicode strings must be word
2446 BCC(smb_buffer_response) / 2;
2449 UniStrnlen((wchar_t *) bcc_ptr,
2450 remaining_words - 1);
2451 /* We look for obvious messed up bcc or strings in response so we do not go off
2452 the end since (at least) WIN2K and Windows XP have a major bug in not null
2453 terminating last Unicode string in response */
2455 kfree(ses->serverOS);
2456 ses->serverOS = kzalloc(2 * (len + 1),
2458 if (ses->serverOS == NULL)
2459 goto sesssetup_nomem;
2460 cifs_strfromUCS_le(ses->serverOS,
2463 bcc_ptr += 2 * (len + 1);
2464 remaining_words -= len + 1;
2465 ses->serverOS[2 * len] = 0;
2466 ses->serverOS[1 + (2 * len)] = 0;
2467 if (remaining_words > 0) {
2468 len = UniStrnlen((wchar_t *)bcc_ptr,
2470 kfree(ses->serverNOS);
2471 ses->serverNOS = kzalloc(2 * (len + 1),
2473 if (ses->serverNOS == NULL)
2474 goto sesssetup_nomem;
2475 cifs_strfromUCS_le(ses->serverNOS,
2478 bcc_ptr += 2 * (len + 1);
2479 ses->serverNOS[2 * len] = 0;
2480 ses->serverNOS[1 + (2 * len)] = 0;
2481 if (strncmp(ses->serverNOS,
2482 "NT LAN Manager 4", 16) == 0) {
2483 cFYI(1, ("NT4 server"));
2484 ses->flags |= CIFS_SES_NT4;
2486 remaining_words -= len + 1;
2487 if (remaining_words > 0) {
2488 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2489 /* last string is not always null terminated
2490 (for e.g. for Windows XP & 2000) */
2491 if (ses->serverDomain)
2492 kfree(ses->serverDomain);
2496 if (ses->serverDomain == NULL)
2497 goto sesssetup_nomem;
2498 cifs_strfromUCS_le(ses->serverDomain,
2501 bcc_ptr += 2 * (len + 1);
2502 ses->serverDomain[2*len] = 0;
2503 ses->serverDomain[1+(2*len)] = 0;
2504 } else { /* else no more room so create
2505 dummy domain string */
2506 if (ses->serverDomain)
2507 kfree(ses->serverDomain);
2509 kzalloc(2, GFP_KERNEL);
2511 } else { /* no room so create dummy domain
2514 /* if these kcallocs fail not much we
2515 can do, but better to not fail the
2517 kfree(ses->serverDomain);
2519 kzalloc(2, GFP_KERNEL);
2520 kfree(ses->serverNOS);
2522 kzalloc(2, GFP_KERNEL);
2524 } else { /* ASCII */
2525 len = strnlen(bcc_ptr, 1024);
2526 if (((long) bcc_ptr + len) - (long)
2527 pByteArea(smb_buffer_response)
2528 <= BCC(smb_buffer_response)) {
2529 kfree(ses->serverOS);
2530 ses->serverOS = kzalloc(len + 1,
2532 if (ses->serverOS == NULL)
2533 goto sesssetup_nomem;
2534 strncpy(ses->serverOS, bcc_ptr, len);
2537 /* null terminate the string */
2541 len = strnlen(bcc_ptr, 1024);
2542 kfree(ses->serverNOS);
2543 ses->serverNOS = kzalloc(len + 1,
2545 if (ses->serverNOS == NULL)
2546 goto sesssetup_nomem;
2547 strncpy(ses->serverNOS, bcc_ptr, len);
2552 len = strnlen(bcc_ptr, 1024);
2553 if (ses->serverDomain)
2554 kfree(ses->serverDomain);
2555 ses->serverDomain = kzalloc(len + 1,
2557 if (ses->serverDomain == NULL)
2558 goto sesssetup_nomem;
2559 strncpy(ses->serverDomain, bcc_ptr,
2566 ("Variable field of length %d "
2567 "extends beyond end of smb ",
2572 (" Security Blob Length extends beyond "
2577 (" Invalid Word count %d: ",
2578 smb_buffer_response->WordCount));
2581 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2582 since that could make reconnection harder, and
2583 reconnection might be needed to free memory */
2584 cifs_buf_release(smb_buffer);
2590 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2591 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2592 const struct nls_table *nls_codepage)
2594 struct smb_hdr *smb_buffer;
2595 struct smb_hdr *smb_buffer_response;
2596 SESSION_SETUP_ANDX *pSMB;
2597 SESSION_SETUP_ANDX *pSMBr;
2601 int remaining_words = 0;
2602 int bytes_returned = 0;
2604 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2605 PNEGOTIATE_MESSAGE SecurityBlob;
2606 PCHALLENGE_MESSAGE SecurityBlob2;
2607 __u32 negotiate_flags, capabilities;
2610 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2613 domain = ses->domainName;
2614 *pNTLMv2_flag = false;
2615 smb_buffer = cifs_buf_get();
2616 if (smb_buffer == NULL) {
2619 smb_buffer_response = smb_buffer;
2620 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2621 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2623 /* send SMBsessionSetup here */
2624 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2625 NULL /* no tCon exists yet */ , 12 /* wct */ );
2627 smb_buffer->Mid = GetNextMid(ses->server);
2628 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2629 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2631 pSMB->req.AndXCommand = 0xFF;
2632 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2633 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2635 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2636 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2638 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2639 CAP_EXTENDED_SECURITY;
2640 if (ses->capabilities & CAP_UNICODE) {
2641 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2642 capabilities |= CAP_UNICODE;
2644 if (ses->capabilities & CAP_STATUS32) {
2645 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2646 capabilities |= CAP_STATUS32;
2648 if (ses->capabilities & CAP_DFS) {
2649 smb_buffer->Flags2 |= SMBFLG2_DFS;
2650 capabilities |= CAP_DFS;
2652 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2654 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2655 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2656 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2657 SecurityBlob->MessageType = NtLmNegotiate;
2659 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2660 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2661 NTLMSSP_NEGOTIATE_56 |
2662 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2664 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2665 /* if (ntlmv2_support)
2666 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2667 /* setup pointers to domain name and workstation name */
2668 bcc_ptr += SecurityBlobLength;
2670 SecurityBlob->WorkstationName.Buffer = 0;
2671 SecurityBlob->WorkstationName.Length = 0;
2672 SecurityBlob->WorkstationName.MaximumLength = 0;
2674 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2675 along with username on auth request (ie the response to challenge) */
2676 SecurityBlob->DomainName.Buffer = 0;
2677 SecurityBlob->DomainName.Length = 0;
2678 SecurityBlob->DomainName.MaximumLength = 0;
2679 if (ses->capabilities & CAP_UNICODE) {
2680 if ((long) bcc_ptr % 2) {
2686 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2688 bcc_ptr += 2 * bytes_returned;
2690 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2692 bcc_ptr += 2 * bytes_returned;
2693 bcc_ptr += 2; /* null terminate Linux version */
2695 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2697 bcc_ptr += 2 * bytes_returned;
2700 bcc_ptr += 2; /* null terminate network opsys string */
2703 bcc_ptr += 2; /* null domain */
2704 } else { /* ASCII */
2705 strcpy(bcc_ptr, "Linux version ");
2706 bcc_ptr += strlen("Linux version ");
2707 strcpy(bcc_ptr, utsname()->release);
2708 bcc_ptr += strlen(utsname()->release) + 1;
2709 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2710 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2711 bcc_ptr++; /* empty domain field */
2714 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2715 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2716 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2717 smb_buffer->smb_buf_length += count;
2718 pSMB->req.ByteCount = cpu_to_le16(count);
2720 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2721 &bytes_returned, CIFS_LONG_OP);
2723 if (smb_buffer_response->Status.CifsError ==
2724 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2728 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2729 } else if ((smb_buffer_response->WordCount == 3)
2730 || (smb_buffer_response->WordCount == 4)) {
2731 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2732 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2734 if (action & GUEST_LOGIN)
2735 cFYI(1, (" Guest login"));
2736 /* Do we want to set anything in SesInfo struct when guest login? */
2738 bcc_ptr = pByteArea(smb_buffer_response);
2739 /* response can have either 3 or 4 word count - Samba sends 3 */
2741 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2742 if (SecurityBlob2->MessageType != NtLmChallenge) {
2744 ("Unexpected NTLMSSP message type received %d",
2745 SecurityBlob2->MessageType));
2747 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2748 cFYI(1, ("UID = %d", ses->Suid));
2749 if ((pSMBr->resp.hdr.WordCount == 3)
2750 || ((pSMBr->resp.hdr.WordCount == 4)
2752 pSMBr->resp.ByteCount))) {
2754 if (pSMBr->resp.hdr.WordCount == 4) {
2755 bcc_ptr += blob_len;
2756 cFYI(1, ("Security Blob Length %d",
2760 cFYI(1, ("NTLMSSP Challenge rcvd"));
2762 memcpy(ses->server->cryptKey,
2763 SecurityBlob2->Challenge,
2764 CIFS_CRYPTO_KEY_SIZE);
2765 if (SecurityBlob2->NegotiateFlags &
2766 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2767 *pNTLMv2_flag = true;
2769 if ((SecurityBlob2->NegotiateFlags &
2770 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2771 || (sign_CIFS_PDUs > 1))
2772 ses->server->secMode |=
2773 SECMODE_SIGN_REQUIRED;
2774 if ((SecurityBlob2->NegotiateFlags &
2775 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2776 ses->server->secMode |=
2777 SECMODE_SIGN_ENABLED;
2779 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2780 if ((long) (bcc_ptr) % 2) {
2782 (BCC(smb_buffer_response)
2784 /* Must word align unicode strings */
2789 (smb_buffer_response) / 2;
2792 UniStrnlen((wchar_t *) bcc_ptr,
2793 remaining_words - 1);
2794 /* We look for obvious messed up bcc or strings in response so we do not go off
2795 the end since (at least) WIN2K and Windows XP have a major bug in not null
2796 terminating last Unicode string in response */
2798 kfree(ses->serverOS);
2800 kzalloc(2 * (len + 1), GFP_KERNEL);
2801 cifs_strfromUCS_le(ses->serverOS,
2805 bcc_ptr += 2 * (len + 1);
2806 remaining_words -= len + 1;
2807 ses->serverOS[2 * len] = 0;
2808 ses->serverOS[1 + (2 * len)] = 0;
2809 if (remaining_words > 0) {
2810 len = UniStrnlen((wchar_t *)
2814 kfree(ses->serverNOS);
2816 kzalloc(2 * (len + 1),
2818 cifs_strfromUCS_le(ses->
2824 bcc_ptr += 2 * (len + 1);
2825 ses->serverNOS[2 * len] = 0;
2828 remaining_words -= len + 1;
2829 if (remaining_words > 0) {
2830 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2831 /* last string not always null terminated
2832 (for e.g. for Windows XP & 2000) */
2833 kfree(ses->serverDomain);
2845 ses->serverDomain[2*len]
2850 } /* else no more room so create dummy domain string */
2852 kfree(ses->serverDomain);
2857 } else { /* no room so create dummy domain and NOS string */
2858 kfree(ses->serverDomain);
2860 kzalloc(2, GFP_KERNEL);
2861 kfree(ses->serverNOS);
2863 kzalloc(2, GFP_KERNEL);
2865 } else { /* ASCII */
2866 len = strnlen(bcc_ptr, 1024);
2867 if (((long) bcc_ptr + len) - (long)
2868 pByteArea(smb_buffer_response)
2869 <= BCC(smb_buffer_response)) {
2871 kfree(ses->serverOS);
2875 strncpy(ses->serverOS,
2879 bcc_ptr[0] = 0; /* null terminate string */
2882 len = strnlen(bcc_ptr, 1024);
2883 kfree(ses->serverNOS);
2887 strncpy(ses->serverNOS, bcc_ptr, len);
2892 len = strnlen(bcc_ptr, 1024);
2893 kfree(ses->serverDomain);
2897 strncpy(ses->serverDomain,
2904 ("field of length %d "
2905 "extends beyond end of smb",
2909 cERROR(1, ("Security Blob Length extends beyond"
2913 cERROR(1, ("No session structure passed in."));
2917 (" Invalid Word count %d:",
2918 smb_buffer_response->WordCount));
2922 cifs_buf_release(smb_buffer);
2927 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2928 char *ntlm_session_key, bool ntlmv2_flag,
2929 const struct nls_table *nls_codepage)
2931 struct smb_hdr *smb_buffer;
2932 struct smb_hdr *smb_buffer_response;
2933 SESSION_SETUP_ANDX *pSMB;
2934 SESSION_SETUP_ANDX *pSMBr;
2939 int remaining_words = 0;
2940 int bytes_returned = 0;
2942 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2943 PAUTHENTICATE_MESSAGE SecurityBlob;
2944 __u32 negotiate_flags, capabilities;
2947 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2950 user = ses->userName;
2951 domain = ses->domainName;
2952 smb_buffer = cifs_buf_get();
2953 if (smb_buffer == NULL) {
2956 smb_buffer_response = smb_buffer;
2957 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2958 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2960 /* send SMBsessionSetup here */
2961 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2962 NULL /* no tCon exists yet */ , 12 /* wct */ );
2964 smb_buffer->Mid = GetNextMid(ses->server);
2965 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2966 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2967 pSMB->req.AndXCommand = 0xFF;
2968 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2969 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2971 pSMB->req.hdr.Uid = ses->Suid;
2973 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2974 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2976 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2977 CAP_EXTENDED_SECURITY;
2978 if (ses->capabilities & CAP_UNICODE) {
2979 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2980 capabilities |= CAP_UNICODE;
2982 if (ses->capabilities & CAP_STATUS32) {
2983 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2984 capabilities |= CAP_STATUS32;
2986 if (ses->capabilities & CAP_DFS) {
2987 smb_buffer->Flags2 |= SMBFLG2_DFS;
2988 capabilities |= CAP_DFS;
2990 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2992 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
2993 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
2994 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2995 SecurityBlob->MessageType = NtLmAuthenticate;
2996 bcc_ptr += SecurityBlobLength;
2997 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
2998 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
2999 0x80000000 | NTLMSSP_NEGOTIATE_128;
3001 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3003 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3005 /* setup pointers to domain name and workstation name */
3007 SecurityBlob->WorkstationName.Buffer = 0;
3008 SecurityBlob->WorkstationName.Length = 0;
3009 SecurityBlob->WorkstationName.MaximumLength = 0;
3010 SecurityBlob->SessionKey.Length = 0;
3011 SecurityBlob->SessionKey.MaximumLength = 0;
3012 SecurityBlob->SessionKey.Buffer = 0;
3014 SecurityBlob->LmChallengeResponse.Length = 0;
3015 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3016 SecurityBlob->LmChallengeResponse.Buffer = 0;
3018 SecurityBlob->NtChallengeResponse.Length =
3019 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3020 SecurityBlob->NtChallengeResponse.MaximumLength =
3021 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3022 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3023 SecurityBlob->NtChallengeResponse.Buffer =
3024 cpu_to_le32(SecurityBlobLength);
3025 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3026 bcc_ptr += CIFS_SESS_KEY_SIZE;
3028 if (ses->capabilities & CAP_UNICODE) {
3029 if (domain == NULL) {
3030 SecurityBlob->DomainName.Buffer = 0;
3031 SecurityBlob->DomainName.Length = 0;
3032 SecurityBlob->DomainName.MaximumLength = 0;
3034 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3037 SecurityBlob->DomainName.MaximumLength =
3039 SecurityBlob->DomainName.Buffer =
3040 cpu_to_le32(SecurityBlobLength);
3042 SecurityBlobLength += ln;
3043 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3046 SecurityBlob->UserName.Buffer = 0;
3047 SecurityBlob->UserName.Length = 0;
3048 SecurityBlob->UserName.MaximumLength = 0;
3050 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3053 SecurityBlob->UserName.MaximumLength =
3055 SecurityBlob->UserName.Buffer =
3056 cpu_to_le32(SecurityBlobLength);
3058 SecurityBlobLength += ln;
3059 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3062 /* SecurityBlob->WorkstationName.Length =
3063 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3064 SecurityBlob->WorkstationName.Length *= 2;
3065 SecurityBlob->WorkstationName.MaximumLength =
3066 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3067 SecurityBlob->WorkstationName.Buffer =
3068 cpu_to_le32(SecurityBlobLength);
3069 bcc_ptr += SecurityBlob->WorkstationName.Length;
3070 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3071 SecurityBlob->WorkstationName.Length =
3072 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3074 if ((long) bcc_ptr % 2) {
3079 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3081 bcc_ptr += 2 * bytes_returned;
3083 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3085 bcc_ptr += 2 * bytes_returned;
3086 bcc_ptr += 2; /* null term version string */
3088 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3090 bcc_ptr += 2 * bytes_returned;
3093 bcc_ptr += 2; /* null terminate network opsys string */
3096 bcc_ptr += 2; /* null domain */
3097 } else { /* ASCII */
3098 if (domain == NULL) {
3099 SecurityBlob->DomainName.Buffer = 0;
3100 SecurityBlob->DomainName.Length = 0;
3101 SecurityBlob->DomainName.MaximumLength = 0;
3104 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3105 strncpy(bcc_ptr, domain, 63);
3106 ln = strnlen(domain, 64);
3107 SecurityBlob->DomainName.MaximumLength =
3109 SecurityBlob->DomainName.Buffer =
3110 cpu_to_le32(SecurityBlobLength);
3112 SecurityBlobLength += ln;
3113 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3116 SecurityBlob->UserName.Buffer = 0;
3117 SecurityBlob->UserName.Length = 0;
3118 SecurityBlob->UserName.MaximumLength = 0;
3121 strncpy(bcc_ptr, user, 63);
3122 ln = strnlen(user, 64);
3123 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3124 SecurityBlob->UserName.Buffer =
3125 cpu_to_le32(SecurityBlobLength);
3127 SecurityBlobLength += ln;
3128 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3130 /* BB fill in our workstation name if known BB */
3132 strcpy(bcc_ptr, "Linux version ");
3133 bcc_ptr += strlen("Linux version ");
3134 strcpy(bcc_ptr, utsname()->release);
3135 bcc_ptr += strlen(utsname()->release) + 1;
3136 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3137 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3138 bcc_ptr++; /* null domain */
3141 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3142 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3143 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3144 smb_buffer->smb_buf_length += count;
3145 pSMB->req.ByteCount = cpu_to_le16(count);
3147 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3148 &bytes_returned, CIFS_LONG_OP);
3150 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3151 } else if ((smb_buffer_response->WordCount == 3) ||
3152 (smb_buffer_response->WordCount == 4)) {
3153 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3154 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3155 if (action & GUEST_LOGIN)
3156 cFYI(1, (" Guest login")); /* BB Should we set anything
3157 in SesInfo struct ? */
3158 /* if (SecurityBlob2->MessageType != NtLm??) {
3159 cFYI("Unexpected message type on auth response is %d"));
3164 ("Check challenge UID %d vs auth response UID %d",
3165 ses->Suid, smb_buffer_response->Uid));
3166 /* UID left in wire format */
3167 ses->Suid = smb_buffer_response->Uid;
3168 bcc_ptr = pByteArea(smb_buffer_response);
3169 /* response can have either 3 or 4 word count - Samba sends 3 */
3170 if ((pSMBr->resp.hdr.WordCount == 3)
3171 || ((pSMBr->resp.hdr.WordCount == 4)
3173 pSMBr->resp.ByteCount))) {
3174 if (pSMBr->resp.hdr.WordCount == 4) {
3178 ("Security Blob Length %d ",
3183 ("NTLMSSP response to Authenticate "));
3185 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3186 if ((long) (bcc_ptr) % 2) {
3188 (BCC(smb_buffer_response)
3190 bcc_ptr++; /* Unicode strings must be word aligned */
3192 remaining_words = BCC(smb_buffer_response) / 2;
3194 len = UniStrnlen((wchar_t *) bcc_ptr,
3195 remaining_words - 1);
3196 /* We look for obvious messed up bcc or strings in response so we do not go off
3197 the end since (at least) WIN2K and Windows XP have a major bug in not null
3198 terminating last Unicode string in response */
3200 kfree(ses->serverOS);
3202 kzalloc(2 * (len + 1), GFP_KERNEL);
3203 cifs_strfromUCS_le(ses->serverOS,
3207 bcc_ptr += 2 * (len + 1);
3208 remaining_words -= len + 1;
3209 ses->serverOS[2 * len] = 0;
3210 ses->serverOS[1 + (2 * len)] = 0;
3211 if (remaining_words > 0) {
3212 len = UniStrnlen((wchar_t *)
3216 kfree(ses->serverNOS);
3218 kzalloc(2 * (len + 1),
3220 cifs_strfromUCS_le(ses->
3226 bcc_ptr += 2 * (len + 1);
3227 ses->serverNOS[2 * len] = 0;
3228 ses->serverNOS[1+(2*len)] = 0;
3229 remaining_words -= len + 1;
3230 if (remaining_words > 0) {
3231 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3232 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3233 if (ses->serverDomain)
3234 kfree(ses->serverDomain);
3259 } /* else no more room so create dummy domain string */
3261 if (ses->serverDomain)
3262 kfree(ses->serverDomain);
3263 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3265 } else { /* no room so create dummy domain and NOS string */
3266 if (ses->serverDomain)
3267 kfree(ses->serverDomain);
3268 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3269 kfree(ses->serverNOS);
3270 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3272 } else { /* ASCII */
3273 len = strnlen(bcc_ptr, 1024);
3274 if (((long) bcc_ptr + len) -
3275 (long) pByteArea(smb_buffer_response)
3276 <= BCC(smb_buffer_response)) {
3278 kfree(ses->serverOS);
3279 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3280 strncpy(ses->serverOS,bcc_ptr, len);
3283 bcc_ptr[0] = 0; /* null terminate the string */
3286 len = strnlen(bcc_ptr, 1024);
3287 kfree(ses->serverNOS);
3288 ses->serverNOS = kzalloc(len+1,
3290 strncpy(ses->serverNOS,
3296 len = strnlen(bcc_ptr, 1024);
3297 if (ses->serverDomain)
3298 kfree(ses->serverDomain);
3302 strncpy(ses->serverDomain,
3308 cFYI(1, ("field of length %d "
3309 "extends beyond end of smb ",
3313 cERROR(1, ("Security Blob extends beyond end "
3317 cERROR(1, ("No session structure passed in."));
3320 cERROR(1, ("Invalid Word count %d: ",
3321 smb_buffer_response->WordCount));
3325 cifs_buf_release(smb_buffer);
3331 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3332 const char *tree, struct cifsTconInfo *tcon,
3333 const struct nls_table *nls_codepage)
3335 struct smb_hdr *smb_buffer;
3336 struct smb_hdr *smb_buffer_response;
3339 unsigned char *bcc_ptr;
3347 smb_buffer = cifs_buf_get();
3348 if (smb_buffer == NULL) {
3351 smb_buffer_response = smb_buffer;
3353 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3354 NULL /*no tid */ , 4 /*wct */ );
3356 smb_buffer->Mid = GetNextMid(ses->server);
3357 smb_buffer->Uid = ses->Suid;
3358 pSMB = (TCONX_REQ *) smb_buffer;
3359 pSMBr = (TCONX_RSP *) smb_buffer_response;
3361 pSMB->AndXCommand = 0xFF;
3362 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3363 bcc_ptr = &pSMB->Password[0];
3364 if ((ses->server->secMode) & SECMODE_USER) {
3365 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3366 *bcc_ptr = 0; /* password is null byte */
3367 bcc_ptr++; /* skip password */
3368 /* already aligned so no need to do it below */
3370 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3371 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3372 specified as required (when that support is added to
3373 the vfs in the future) as only NTLM or the much
3374 weaker LANMAN (which we do not send by default) is accepted
3375 by Samba (not sure whether other servers allow
3376 NTLMv2 password here) */
3377 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3378 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3379 (ses->server->secType == LANMAN))
3380 calc_lanman_hash(ses, bcc_ptr);
3382 #endif /* CIFS_WEAK_PW_HASH */
3383 SMBNTencrypt(ses->password,
3384 ses->server->cryptKey,
3387 bcc_ptr += CIFS_SESS_KEY_SIZE;
3388 if (ses->capabilities & CAP_UNICODE) {
3389 /* must align unicode strings */
3390 *bcc_ptr = 0; /* null byte password */
3395 if (ses->server->secMode &
3396 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3397 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3399 if (ses->capabilities & CAP_STATUS32) {
3400 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3402 if (ses->capabilities & CAP_DFS) {
3403 smb_buffer->Flags2 |= SMBFLG2_DFS;
3405 if (ses->capabilities & CAP_UNICODE) {
3406 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3408 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3409 6 /* max utf8 char length in bytes */ *
3410 (/* server len*/ + 256 /* share len */), nls_codepage);
3411 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3412 bcc_ptr += 2; /* skip trailing null */
3413 } else { /* ASCII */
3414 strcpy(bcc_ptr, tree);
3415 bcc_ptr += strlen(tree) + 1;
3417 strcpy(bcc_ptr, "?????");
3418 bcc_ptr += strlen("?????");
3420 count = bcc_ptr - &pSMB->Password[0];
3421 pSMB->hdr.smb_buf_length += count;
3422 pSMB->ByteCount = cpu_to_le16(count);
3424 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3427 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3428 /* above now done in SendReceive */
3429 if ((rc == 0) && (tcon != NULL)) {
3430 tcon->tidStatus = CifsGood;
3431 tcon->tid = smb_buffer_response->Tid;
3432 bcc_ptr = pByteArea(smb_buffer_response);
3433 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3434 /* skip service field (NB: this field is always ASCII) */
3436 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3437 (bcc_ptr[2] == 'C')) {
3438 cFYI(1, ("IPC connection"));
3441 } else if (length == 2) {
3442 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3443 /* the most common case */
3444 cFYI(1, ("disk share connection"));
3447 bcc_ptr += length + 1;
3448 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3449 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3450 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3451 if ((bcc_ptr + (2 * length)) -
3452 pByteArea(smb_buffer_response) <=
3453 BCC(smb_buffer_response)) {
3454 kfree(tcon->nativeFileSystem);
3455 tcon->nativeFileSystem =
3456 kzalloc(length + 2, GFP_KERNEL);
3457 if (tcon->nativeFileSystem)
3459 tcon->nativeFileSystem,
3461 length, nls_codepage);
3462 bcc_ptr += 2 * length;
3463 bcc_ptr[0] = 0; /* null terminate the string */
3467 /* else do not bother copying these information fields*/
3469 length = strnlen(bcc_ptr, 1024);
3470 if ((bcc_ptr + length) -
3471 pByteArea(smb_buffer_response) <=
3472 BCC(smb_buffer_response)) {
3473 kfree(tcon->nativeFileSystem);
3474 tcon->nativeFileSystem =
3475 kzalloc(length + 1, GFP_KERNEL);
3476 if (tcon->nativeFileSystem)
3477 strncpy(tcon->nativeFileSystem, bcc_ptr,
3480 /* else do not bother copying these information fields*/
3482 if ((smb_buffer_response->WordCount == 3) ||
3483 (smb_buffer_response->WordCount == 7))
3484 /* field is in same location */
3485 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3488 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3489 } else if ((rc == 0) && tcon == NULL) {
3490 /* all we need to save for IPC$ connection */
3491 ses->ipc_tid = smb_buffer_response->Tid;
3494 cifs_buf_release(smb_buffer);
3499 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3503 struct cifsSesInfo *ses = NULL;
3504 struct task_struct *cifsd_task;
3509 if (cifs_sb->tcon) {
3510 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3511 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3516 DeleteTconOplockQEntries(cifs_sb->tcon);
3517 tconInfoFree(cifs_sb->tcon);
3518 if ((ses) && (ses->server)) {
3519 /* save off task so we do not refer to ses later */
3520 cifsd_task = ses->server->tsk;
3521 cFYI(1, ("About to do SMBLogoff "));
3522 rc = CIFSSMBLogoff(xid, ses);
3526 } else if (rc == -ESHUTDOWN) {
3527 cFYI(1, ("Waking up socket by sending signal"));
3529 force_sig(SIGKILL, cifsd_task);
3530 kthread_stop(cifsd_task);
3533 } /* else - we have an smb session
3534 left on this socket do not kill cifsd */
3536 cFYI(1, ("No session or bad tcon"));
3539 cifs_sb->tcon = NULL;
3540 tmp = cifs_sb->prepath;
3541 cifs_sb->prepathlen = 0;
3542 cifs_sb->prepath = NULL;
3551 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3552 struct nls_table *nls_info)
3555 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3556 bool ntlmv2_flag = false;
3559 /* what if server changes its buffer size after dropping the session? */
3560 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3561 rc = CIFSSMBNegotiate(xid, pSesInfo);
3562 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3563 rc = CIFSSMBNegotiate(xid, pSesInfo);
3568 spin_lock(&GlobalMid_Lock);
3569 if (pSesInfo->server->tcpStatus != CifsExiting)
3570 pSesInfo->server->tcpStatus = CifsGood;
3573 spin_unlock(&GlobalMid_Lock);
3579 pSesInfo->flags = 0;
3580 pSesInfo->capabilities = pSesInfo->server->capabilities;
3581 if (linuxExtEnabled == 0)
3582 pSesInfo->capabilities &= (~CAP_UNIX);
3583 /* pSesInfo->sequence_number = 0;*/
3585 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3586 pSesInfo->server->secMode,
3587 pSesInfo->server->capabilities,
3588 pSesInfo->server->timeAdj));
3589 if (experimEnabled < 2)
3590 rc = CIFS_SessSetup(xid, pSesInfo,
3591 first_time, nls_info);
3592 else if (extended_security
3593 && (pSesInfo->capabilities
3594 & CAP_EXTENDED_SECURITY)
3595 && (pSesInfo->server->secType == NTLMSSP)) {
3597 } else if (extended_security
3598 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3599 && (pSesInfo->server->secType == RawNTLMSSP)) {
3600 cFYI(1, ("NTLMSSP sesssetup"));
3601 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3608 cFYI(1, ("more secure NTLM ver2 hash"));
3609 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3614 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3616 CalcNTLMv2_response(pSesInfo,
3619 cifs_calculate_ntlmv2_mac_key(
3620 pSesInfo->server->mac_signing_key,
3621 response, ntlm_session_key,*/
3623 /* BB Put dummy sig in SessSetup PDU? */
3630 SMBNTencrypt(pSesInfo->password,
3631 pSesInfo->server->cryptKey,
3635 cifs_calculate_mac_key(
3636 &pSesInfo->server->mac_signing_key,
3638 pSesInfo->password);
3640 /* for better security the weaker lanman hash not sent
3641 in AuthSessSetup so we no longer calculate it */
3643 rc = CIFSNTLMSSPAuthSessSetup(xid,
3649 } else { /* old style NTLM 0.12 session setup */
3650 SMBNTencrypt(pSesInfo->password,
3651 pSesInfo->server->cryptKey,
3655 cifs_calculate_mac_key(
3656 &pSesInfo->server->mac_signing_key,
3657 ntlm_session_key, pSesInfo->password);
3659 rc = CIFSSessSetup(xid, pSesInfo,
3660 ntlm_session_key, nls_info);
3663 cERROR(1, ("Send error in SessSetup = %d", rc));
3665 cFYI(1, ("CIFS Session Established successfully"));
3666 pSesInfo->status = CifsGood;