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)
1429 *pnum_referrals = 0;
1432 if (pSesInfo->ipc_tid == 0) {
1433 temp_unc = kmalloc(2 /* for slashes */ +
1434 strnlen(pSesInfo->serverName,
1435 SERVER_NAME_LEN_WITH_NULL * 2)
1436 + 1 + 4 /* slash IPC$ */ + 2,
1438 if (temp_unc == NULL)
1442 strcpy(temp_unc + 2, pSesInfo->serverName);
1443 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1444 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1446 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1450 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1451 pnum_referrals, nls_codepage, remap);
1452 /* BB map targetUNCs to dfs_info3 structures, here or
1453 in CIFSGetDFSRefer BB */
1458 /* See RFC1001 section 14 on representation of Netbios names */
1459 static void rfc1002mangle(char *target, char *source, unsigned int length)
1463 for (i = 0, j = 0; i < (length); i++) {
1464 /* mask a nibble at a time and encode */
1465 target[j] = 'A' + (0x0F & (source[i] >> 4));
1466 target[j+1] = 'A' + (0x0F & source[i]);
1474 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1475 char *netbios_name, char *target_name)
1479 __be16 orig_port = 0;
1481 if (*csocket == NULL) {
1482 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1483 IPPROTO_TCP, csocket);
1485 cERROR(1, ("Error %d creating socket", rc));
1489 /* BB other socket options to set KEEPALIVE, NODELAY? */
1490 cFYI(1, ("Socket created"));
1491 (*csocket)->sk->sk_allocation = GFP_NOFS;
1495 psin_server->sin_family = AF_INET;
1496 if (psin_server->sin_port) { /* user overrode default port */
1497 rc = (*csocket)->ops->connect(*csocket,
1498 (struct sockaddr *) psin_server,
1499 sizeof(struct sockaddr_in), 0);
1505 /* save original port so we can retry user specified port
1506 later if fall back ports fail this time */
1507 orig_port = psin_server->sin_port;
1509 /* do not retry on the same port we just failed on */
1510 if (psin_server->sin_port != htons(CIFS_PORT)) {
1511 psin_server->sin_port = htons(CIFS_PORT);
1513 rc = (*csocket)->ops->connect(*csocket,
1514 (struct sockaddr *) psin_server,
1515 sizeof(struct sockaddr_in), 0);
1521 psin_server->sin_port = htons(RFC1001_PORT);
1522 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1524 sizeof(struct sockaddr_in), 0);
1529 /* give up here - unless we want to retry on different
1530 protocol families some day */
1533 psin_server->sin_port = orig_port;
1534 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1535 sock_release(*csocket);
1539 /* Eventually check for other socket options to change from
1540 the default. sock_setsockopt not used because it expects
1541 user space buffer */
1542 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1543 (*csocket)->sk->sk_sndbuf,
1544 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1545 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1546 /* make the bufsizes depend on wsize/rsize and max requests */
1547 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1548 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1549 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1550 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1552 /* send RFC1001 sessinit */
1553 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1554 /* some servers require RFC1001 sessinit before sending
1555 negprot - BB check reconnection in case where second
1556 sessinit is sent but no second negprot */
1557 struct rfc1002_session_packet *ses_init_buf;
1558 struct smb_hdr *smb_buf;
1559 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1562 ses_init_buf->trailer.session_req.called_len = 32;
1563 if (target_name && (target_name[0] != 0)) {
1564 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1567 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1568 DEFAULT_CIFS_CALLED_NAME, 16);
1571 ses_init_buf->trailer.session_req.calling_len = 32;
1572 /* calling name ends in null (byte 16) from old smb
1574 if (netbios_name && (netbios_name[0] != 0)) {
1575 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1578 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1579 "LINUX_CIFS_CLNT", 16);
1581 ses_init_buf->trailer.session_req.scope1 = 0;
1582 ses_init_buf->trailer.session_req.scope2 = 0;
1583 smb_buf = (struct smb_hdr *)ses_init_buf;
1584 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1585 smb_buf->smb_buf_length = 0x81000044;
1586 rc = smb_send(*csocket, smb_buf, 0x44,
1587 (struct sockaddr *)psin_server);
1588 kfree(ses_init_buf);
1589 msleep(1); /* RFC1001 layer in at least one server
1590 requires very short break before negprot
1591 presumably because not expecting negprot
1592 to follow so fast. This is a simple
1593 solution that works without
1594 complicating the code and causes no
1595 significant slowing down on mount
1596 for everyone else */
1598 /* else the negprot may still work without this
1599 even though malloc failed */
1607 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1611 __be16 orig_port = 0;
1613 if (*csocket == NULL) {
1614 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1615 IPPROTO_TCP, csocket);
1617 cERROR(1, ("Error %d creating ipv6 socket", rc));
1621 /* BB other socket options to set KEEPALIVE, NODELAY? */
1622 cFYI(1, ("ipv6 Socket created"));
1623 (*csocket)->sk->sk_allocation = GFP_NOFS;
1627 psin_server->sin6_family = AF_INET6;
1629 if (psin_server->sin6_port) { /* user overrode default port */
1630 rc = (*csocket)->ops->connect(*csocket,
1631 (struct sockaddr *) psin_server,
1632 sizeof(struct sockaddr_in6), 0);
1638 /* save original port so we can retry user specified port
1639 later if fall back ports fail this time */
1641 orig_port = psin_server->sin6_port;
1642 /* do not retry on the same port we just failed on */
1643 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1644 psin_server->sin6_port = htons(CIFS_PORT);
1646 rc = (*csocket)->ops->connect(*csocket,
1647 (struct sockaddr *) psin_server,
1648 sizeof(struct sockaddr_in6), 0);
1654 psin_server->sin6_port = htons(RFC1001_PORT);
1655 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1656 psin_server, sizeof(struct sockaddr_in6), 0);
1661 /* give up here - unless we want to retry on different
1662 protocol families some day */
1665 psin_server->sin6_port = orig_port;
1666 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1667 sock_release(*csocket);
1671 /* Eventually check for other socket options to change from
1672 the default. sock_setsockopt not used because it expects
1673 user space buffer */
1674 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1679 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1680 struct super_block *sb, struct smb_vol *vol_info)
1682 /* if we are reconnecting then should we check to see if
1683 * any requested capabilities changed locally e.g. via
1684 * remount but we can not do much about it here
1685 * if they have (even if we could detect it by the following)
1686 * Perhaps we could add a backpointer to array of sb from tcon
1687 * or if we change to make all sb to same share the same
1688 * sb as NFS - then we only have one backpointer to sb.
1689 * What if we wanted to mount the server share twice once with
1690 * and once without posixacls or posix paths? */
1691 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1693 if (vol_info && vol_info->no_linux_ext) {
1694 tcon->fsUnixInfo.Capability = 0;
1695 tcon->unix_ext = 0; /* Unix Extensions disabled */
1696 cFYI(1, ("Linux protocol extensions disabled"));
1698 } else if (vol_info)
1699 tcon->unix_ext = 1; /* Unix Extensions supported */
1701 if (tcon->unix_ext == 0) {
1702 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1706 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1707 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1709 /* check for reconnect case in which we do not
1710 want to change the mount behavior if we can avoid it */
1711 if (vol_info == NULL) {
1712 /* turn off POSIX ACL and PATHNAMES if not set
1713 originally at mount time */
1714 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1715 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1716 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1717 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1718 cERROR(1, ("POSIXPATH support change"));
1719 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1720 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1721 cERROR(1, ("possible reconnect error"));
1723 ("server disabled POSIX path support"));
1727 cap &= CIFS_UNIX_CAP_MASK;
1728 if (vol_info && vol_info->no_psx_acl)
1729 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1730 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1731 cFYI(1, ("negotiated posix acl support"));
1733 sb->s_flags |= MS_POSIXACL;
1736 if (vol_info && vol_info->posix_paths == 0)
1737 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1738 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1739 cFYI(1, ("negotiate posix pathnames"));
1741 CIFS_SB(sb)->mnt_cifs_flags |=
1742 CIFS_MOUNT_POSIX_PATHS;
1745 /* We might be setting the path sep back to a different
1746 form if we are reconnecting and the server switched its
1747 posix path capability for this share */
1748 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1749 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1751 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1752 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1753 CIFS_SB(sb)->rsize = 127 * 1024;
1755 ("larger reads not supported by srv"));
1760 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1761 #ifdef CONFIG_CIFS_DEBUG2
1762 if (cap & CIFS_UNIX_FCNTL_CAP)
1763 cFYI(1, ("FCNTL cap"));
1764 if (cap & CIFS_UNIX_EXTATTR_CAP)
1765 cFYI(1, ("EXTATTR cap"));
1766 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1767 cFYI(1, ("POSIX path cap"));
1768 if (cap & CIFS_UNIX_XATTR_CAP)
1769 cFYI(1, ("XATTR cap"));
1770 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1771 cFYI(1, ("POSIX ACL cap"));
1772 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1773 cFYI(1, ("very large read cap"));
1774 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1775 cFYI(1, ("very large write cap"));
1776 #endif /* CIFS_DEBUG2 */
1777 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1778 if (vol_info == NULL) {
1779 cFYI(1, ("resetting capabilities failed"));
1781 cERROR(1, ("Negotiating Unix capabilities "
1782 "with the server failed. Consider "
1783 "mounting with the Unix Extensions\n"
1784 "disabled, if problems are found, "
1785 "by specifying the nounix mount "
1793 convert_delimiter(char *path, char delim)
1806 for (i = 0; path[i] != '\0'; i++) {
1807 if (path[i] == old_delim)
1813 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1814 char *mount_data, const char *devname)
1818 int address_type = AF_INET;
1819 struct socket *csocket = NULL;
1820 struct sockaddr_in sin_server;
1821 struct sockaddr_in6 sin_server6;
1822 struct smb_vol volume_info;
1823 struct cifsSesInfo *pSesInfo = NULL;
1824 struct cifsSesInfo *existingCifsSes = NULL;
1825 struct cifsTconInfo *tcon = NULL;
1826 struct TCP_Server_Info *srvTcp = NULL;
1830 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1832 memset(&volume_info, 0, sizeof(struct smb_vol));
1833 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1838 if (volume_info.nullauth) {
1839 cFYI(1, ("null user"));
1840 volume_info.username = "";
1841 } else if (volume_info.username) {
1842 /* BB fixme parse for domain name here */
1843 cFYI(1, ("Username: %s", volume_info.username));
1845 cifserror("No username specified");
1846 /* In userspace mount helper we can get user name from alternate
1847 locations such as env variables and files on disk */
1852 if (volume_info.UNCip && volume_info.UNC) {
1853 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1854 &sin_server.sin_addr.s_addr);
1857 /* not ipv4 address, try ipv6 */
1858 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1859 &sin_server6.sin6_addr.in6_u);
1861 address_type = AF_INET6;
1863 address_type = AF_INET;
1867 /* we failed translating address */
1872 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1875 } else if (volume_info.UNCip) {
1876 /* BB using ip addr as server name to connect to the
1878 cERROR(1, ("Connecting to DFS root not implemented yet"));
1881 } else /* which servers DFS root would we conect to */ {
1883 ("CIFS mount error: No UNC path (e.g. -o "
1884 "unc=//192.168.1.100/public) specified"));
1889 /* this is needed for ASCII cp to Unicode converts */
1890 if (volume_info.iocharset == NULL) {
1891 cifs_sb->local_nls = load_nls_default();
1892 /* load_nls_default can not return null */
1894 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1895 if (cifs_sb->local_nls == NULL) {
1896 cERROR(1, ("CIFS mount error: iocharset %s not found",
1897 volume_info.iocharset));
1903 if (address_type == AF_INET)
1904 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1905 NULL /* no ipv6 addr */,
1906 volume_info.username, &srvTcp);
1907 else if (address_type == AF_INET6) {
1908 cFYI(1, ("looking for ipv6 address"));
1909 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1910 &sin_server6.sin6_addr,
1911 volume_info.username, &srvTcp);
1918 cFYI(1, ("Existing tcp session with server found"));
1919 } else { /* create socket */
1920 if (volume_info.port)
1921 sin_server.sin_port = htons(volume_info.port);
1923 sin_server.sin_port = 0;
1924 if (address_type == AF_INET6) {
1925 cFYI(1, ("attempting ipv6 connect"));
1926 /* BB should we allow ipv6 on port 139? */
1927 /* other OS never observed in Wild doing 139 with v6 */
1928 rc = ipv6_connect(&sin_server6, &csocket);
1930 rc = ipv4_connect(&sin_server, &csocket,
1931 volume_info.source_rfc1001_name,
1932 volume_info.target_rfc1001_name);
1934 cERROR(1, ("Error connecting to IPv4 socket. "
1935 "Aborting operation"));
1936 if (csocket != NULL)
1937 sock_release(csocket);
1941 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1944 sock_release(csocket);
1947 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1948 sizeof(struct sockaddr_in));
1949 atomic_set(&srvTcp->inFlight, 0);
1950 /* BB Add code for ipv6 case too */
1951 srvTcp->ssocket = csocket;
1952 srvTcp->protocolType = IPV4;
1953 srvTcp->hostname = extract_hostname(volume_info.UNC);
1954 if (IS_ERR(srvTcp->hostname)) {
1955 rc = PTR_ERR(srvTcp->hostname);
1956 sock_release(csocket);
1959 init_waitqueue_head(&srvTcp->response_q);
1960 init_waitqueue_head(&srvTcp->request_q);
1961 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1962 /* at this point we are the only ones with the pointer
1963 to the struct since the kernel thread not created yet
1964 so no need to spinlock this init of tcpStatus */
1965 srvTcp->tcpStatus = CifsNew;
1966 init_MUTEX(&srvTcp->tcpSem);
1967 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1968 if (IS_ERR(srvTcp->tsk)) {
1969 rc = PTR_ERR(srvTcp->tsk);
1970 cERROR(1, ("error %d create cifsd thread", rc));
1972 sock_release(csocket);
1973 kfree(srvTcp->hostname);
1977 memcpy(srvTcp->workstation_RFC1001_name,
1978 volume_info.source_rfc1001_name, 16);
1979 memcpy(srvTcp->server_RFC1001_name,
1980 volume_info.target_rfc1001_name, 16);
1981 srvTcp->sequence_number = 0;
1985 if (existingCifsSes) {
1986 pSesInfo = existingCifsSes;
1987 cFYI(1, ("Existing smb sess found (status=%d)",
1989 down(&pSesInfo->sesSem);
1990 if (pSesInfo->status == CifsNeedReconnect) {
1991 cFYI(1, ("Session needs reconnect"));
1992 rc = cifs_setup_session(xid, pSesInfo,
1993 cifs_sb->local_nls);
1995 up(&pSesInfo->sesSem);
1997 cFYI(1, ("Existing smb sess not found"));
1998 pSesInfo = sesInfoAlloc();
1999 if (pSesInfo == NULL)
2002 pSesInfo->server = srvTcp;
2003 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2004 NIPQUAD(sin_server.sin_addr.s_addr));
2008 /* volume_info.password freed at unmount */
2009 if (volume_info.password) {
2010 pSesInfo->password = volume_info.password;
2011 /* set to NULL to prevent freeing on exit */
2012 volume_info.password = NULL;
2014 if (volume_info.username)
2015 strncpy(pSesInfo->userName,
2016 volume_info.username,
2018 if (volume_info.domainname) {
2019 int len = strlen(volume_info.domainname);
2020 pSesInfo->domainName =
2021 kmalloc(len + 1, GFP_KERNEL);
2022 if (pSesInfo->domainName)
2023 strcpy(pSesInfo->domainName,
2024 volume_info.domainname);
2026 pSesInfo->linux_uid = volume_info.linux_uid;
2027 pSesInfo->overrideSecFlg = volume_info.secFlg;
2028 down(&pSesInfo->sesSem);
2029 /* BB FIXME need to pass vol->secFlgs BB */
2030 rc = cifs_setup_session(xid, pSesInfo,
2031 cifs_sb->local_nls);
2032 up(&pSesInfo->sesSem);
2034 atomic_inc(&srvTcp->socketUseCount);
2038 /* search for existing tcon to this server share */
2040 if (volume_info.rsize > CIFSMaxBufSize) {
2041 cERROR(1, ("rsize %d too large, using MaxBufSize",
2042 volume_info.rsize));
2043 cifs_sb->rsize = CIFSMaxBufSize;
2044 } else if ((volume_info.rsize) &&
2045 (volume_info.rsize <= CIFSMaxBufSize))
2046 cifs_sb->rsize = volume_info.rsize;
2048 cifs_sb->rsize = CIFSMaxBufSize;
2050 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2051 cERROR(1, ("wsize %d too large, using 4096 instead",
2052 volume_info.wsize));
2053 cifs_sb->wsize = 4096;
2054 } else if (volume_info.wsize)
2055 cifs_sb->wsize = volume_info.wsize;
2058 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2060 /* old default of CIFSMaxBufSize was too small now
2061 that SMB Write2 can send multiple pages in kvec.
2062 RFC1001 does not describe what happens when frame
2063 bigger than 128K is sent so use that as max in
2064 conjunction with 52K kvec constraint on arch with 4K
2067 if (cifs_sb->rsize < 2048) {
2068 cifs_sb->rsize = 2048;
2069 /* Windows ME may prefer this */
2070 cFYI(1, ("readsize set to minimum: 2048"));
2072 /* calculate prepath */
2073 cifs_sb->prepath = volume_info.prepath;
2074 if (cifs_sb->prepath) {
2075 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2076 /* we can not convert the / to \ in the path
2077 separators in the prefixpath yet because we do not
2078 know (until reset_cifs_unix_caps is called later)
2079 whether POSIX PATH CAP is available. We normalize
2080 the / to \ after reset_cifs_unix_caps is called */
2081 volume_info.prepath = NULL;
2083 cifs_sb->prepathlen = 0;
2084 cifs_sb->mnt_uid = volume_info.linux_uid;
2085 cifs_sb->mnt_gid = volume_info.linux_gid;
2086 cifs_sb->mnt_file_mode = volume_info.file_mode;
2087 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2088 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2089 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2091 if (volume_info.noperm)
2092 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2093 if (volume_info.setuids)
2094 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2095 if (volume_info.server_ino)
2096 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2097 if (volume_info.remap)
2098 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2099 if (volume_info.no_xattr)
2100 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2101 if (volume_info.sfu_emul)
2102 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2103 if (volume_info.nobrl)
2104 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2105 if (volume_info.cifs_acl)
2106 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2107 if (volume_info.override_uid)
2108 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2109 if (volume_info.override_gid)
2110 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2111 if (volume_info.dynperm)
2112 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2113 if (volume_info.direct_io) {
2114 cFYI(1, ("mounting share using direct i/o"));
2115 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2119 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2120 volume_info.username);
2122 cFYI(1, ("Found match on UNC path"));
2123 /* we can have only one retry value for a connection
2124 to a share so for resources mounted more than once
2125 to the same server share the last value passed in
2126 for the retry flag is used */
2127 tcon->retry = volume_info.retry;
2128 tcon->nocase = volume_info.nocase;
2130 tcon = tconInfoAlloc();
2134 /* check for null share name ie connecting to
2137 /* BB check if this works for exactly length
2139 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2140 && (strchr(volume_info.UNC + 3, '/') ==
2142 /* rc = connect_to_dfs_path(xid, pSesInfo,
2143 "", cifs_sb->local_nls,
2144 cifs_sb->mnt_cifs_flags &
2145 CIFS_MOUNT_MAP_SPECIAL_CHR);*/
2146 cFYI(1, ("DFS root not supported"));
2150 /* BB Do we need to wrap sesSem around
2151 * this TCon call and Unix SetFS as
2152 * we do on SessSetup and reconnect? */
2153 rc = CIFSTCon(xid, pSesInfo,
2155 tcon, cifs_sb->local_nls);
2156 cFYI(1, ("CIFS Tcon rc = %d", rc));
2159 atomic_inc(&pSesInfo->inUse);
2160 tcon->retry = volume_info.retry;
2161 tcon->nocase = volume_info.nocase;
2167 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2168 sb->s_maxbytes = (u64) 1 << 63;
2170 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2173 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2174 sb->s_time_gran = 100;
2176 /* on error free sesinfo and tcon struct if needed */
2178 /* if session setup failed, use count is zero but
2179 we still need to free cifsd thread */
2180 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2181 spin_lock(&GlobalMid_Lock);
2182 srvTcp->tcpStatus = CifsExiting;
2183 spin_unlock(&GlobalMid_Lock);
2185 /* If we could verify that kthread_stop would
2186 always wake up processes blocked in
2187 tcp in recv_mesg then we could remove the
2189 force_sig(SIGKILL, srvTcp->tsk);
2190 kthread_stop(srvTcp->tsk);
2193 /* If find_unc succeeded then rc == 0 so we can not end */
2194 if (tcon) /* up accidently freeing someone elses tcon struct */
2196 if (existingCifsSes == NULL) {
2198 if ((pSesInfo->server) &&
2199 (pSesInfo->status == CifsGood)) {
2201 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2202 /* if the socketUseCount is now zero */
2203 if ((temp_rc == -ESHUTDOWN) &&
2204 (pSesInfo->server) &&
2205 (pSesInfo->server->tsk)) {
2207 pSesInfo->server->tsk);
2208 kthread_stop(pSesInfo->server->tsk);
2211 cFYI(1, ("No session or bad tcon"));
2212 if ((pSesInfo->server) &&
2213 (pSesInfo->server->tsk)) {
2215 pSesInfo->server->tsk);
2216 kthread_stop(pSesInfo->server->tsk);
2219 sesInfoFree(pSesInfo);
2220 /* pSesInfo = NULL; */
2224 atomic_inc(&tcon->useCount);
2225 cifs_sb->tcon = tcon;
2226 tcon->ses = pSesInfo;
2228 /* do not care if following two calls succeed - informational */
2230 CIFSSMBQFSDeviceInfo(xid, tcon);
2231 CIFSSMBQFSAttributeInfo(xid, tcon);
2234 /* tell server which Unix caps we support */
2235 if (tcon->ses->capabilities & CAP_UNIX)
2236 /* reset of caps checks mount to see if unix extensions
2237 disabled for just this mount */
2238 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2240 tcon->unix_ext = 0; /* server does not support them */
2242 /* convert forward to back slashes in prepath here if needed */
2243 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2244 convert_delimiter(cifs_sb->prepath,
2245 CIFS_DIR_SEP(cifs_sb));
2247 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2248 cifs_sb->rsize = 1024 * 127;
2250 ("no very large read support, rsize now 127K"));
2252 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2253 cifs_sb->wsize = min(cifs_sb->wsize,
2254 (tcon->ses->server->maxBuf -
2255 MAX_CIFS_HDR_SIZE));
2256 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2257 cifs_sb->rsize = min(cifs_sb->rsize,
2258 (tcon->ses->server->maxBuf -
2259 MAX_CIFS_HDR_SIZE));
2262 /* volume_info.password is freed above when existing session found
2263 (in which case it is not needed anymore) but when new sesion is created
2264 the password ptr is put in the new session structure (in which case the
2265 password will be freed at unmount time) */
2267 /* zero out password before freeing */
2268 if (volume_info.password != NULL) {
2269 memset(volume_info.password, 0, strlen(volume_info.password));
2270 kfree(volume_info.password);
2272 kfree(volume_info.UNC);
2273 kfree(volume_info.prepath);
2279 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2280 char session_key[CIFS_SESS_KEY_SIZE],
2281 const struct nls_table *nls_codepage)
2283 struct smb_hdr *smb_buffer;
2284 struct smb_hdr *smb_buffer_response;
2285 SESSION_SETUP_ANDX *pSMB;
2286 SESSION_SETUP_ANDX *pSMBr;
2291 int remaining_words = 0;
2292 int bytes_returned = 0;
2297 cFYI(1, ("In sesssetup"));
2300 user = ses->userName;
2301 domain = ses->domainName;
2302 smb_buffer = cifs_buf_get();
2304 if (smb_buffer == NULL)
2307 smb_buffer_response = smb_buffer;
2308 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2310 /* send SMBsessionSetup here */
2311 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2312 NULL /* no tCon exists yet */ , 13 /* wct */ );
2314 smb_buffer->Mid = GetNextMid(ses->server);
2315 pSMB->req_no_secext.AndXCommand = 0xFF;
2316 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2317 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2319 if (ses->server->secMode &
2320 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2321 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2323 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2324 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2325 if (ses->capabilities & CAP_UNICODE) {
2326 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2327 capabilities |= CAP_UNICODE;
2329 if (ses->capabilities & CAP_STATUS32) {
2330 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2331 capabilities |= CAP_STATUS32;
2333 if (ses->capabilities & CAP_DFS) {
2334 smb_buffer->Flags2 |= SMBFLG2_DFS;
2335 capabilities |= CAP_DFS;
2337 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2339 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2340 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2342 pSMB->req_no_secext.CaseSensitivePasswordLength =
2343 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2344 bcc_ptr = pByteArea(smb_buffer);
2345 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2346 bcc_ptr += CIFS_SESS_KEY_SIZE;
2347 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2348 bcc_ptr += CIFS_SESS_KEY_SIZE;
2350 if (ses->capabilities & CAP_UNICODE) {
2351 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2356 bytes_returned = 0; /* skip null user */
2359 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2361 /* convert number of 16 bit words to bytes */
2362 bcc_ptr += 2 * bytes_returned;
2363 bcc_ptr += 2; /* trailing null */
2366 cifs_strtoUCS((__le16 *) bcc_ptr,
2367 "CIFS_LINUX_DOM", 32, nls_codepage);
2370 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2372 bcc_ptr += 2 * bytes_returned;
2375 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2377 bcc_ptr += 2 * bytes_returned;
2379 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2381 bcc_ptr += 2 * bytes_returned;
2384 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2386 bcc_ptr += 2 * bytes_returned;
2390 strncpy(bcc_ptr, user, 200);
2391 bcc_ptr += strnlen(user, 200);
2395 if (domain == NULL) {
2396 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2397 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2399 strncpy(bcc_ptr, domain, 64);
2400 bcc_ptr += strnlen(domain, 64);
2404 strcpy(bcc_ptr, "Linux version ");
2405 bcc_ptr += strlen("Linux version ");
2406 strcpy(bcc_ptr, utsname()->release);
2407 bcc_ptr += strlen(utsname()->release) + 1;
2408 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2409 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2411 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2412 smb_buffer->smb_buf_length += count;
2413 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2415 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2416 &bytes_returned, CIFS_LONG_OP);
2418 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2419 } else if ((smb_buffer_response->WordCount == 3)
2420 || (smb_buffer_response->WordCount == 4)) {
2421 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2422 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2423 if (action & GUEST_LOGIN)
2424 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2425 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2427 cFYI(1, ("UID = %d ", ses->Suid));
2428 /* response can have either 3 or 4 word count - Samba sends 3 */
2429 bcc_ptr = pByteArea(smb_buffer_response);
2430 if ((pSMBr->resp.hdr.WordCount == 3)
2431 || ((pSMBr->resp.hdr.WordCount == 4)
2432 && (blob_len < pSMBr->resp.ByteCount))) {
2433 if (pSMBr->resp.hdr.WordCount == 4)
2434 bcc_ptr += blob_len;
2436 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2437 if ((long) (bcc_ptr) % 2) {
2439 (BCC(smb_buffer_response) - 1) / 2;
2440 /* Unicode strings must be word
2445 BCC(smb_buffer_response) / 2;
2448 UniStrnlen((wchar_t *) bcc_ptr,
2449 remaining_words - 1);
2450 /* We look for obvious messed up bcc or strings in response so we do not go off
2451 the end since (at least) WIN2K and Windows XP have a major bug in not null
2452 terminating last Unicode string in response */
2454 kfree(ses->serverOS);
2455 ses->serverOS = kzalloc(2 * (len + 1),
2457 if (ses->serverOS == NULL)
2458 goto sesssetup_nomem;
2459 cifs_strfromUCS_le(ses->serverOS,
2462 bcc_ptr += 2 * (len + 1);
2463 remaining_words -= len + 1;
2464 ses->serverOS[2 * len] = 0;
2465 ses->serverOS[1 + (2 * len)] = 0;
2466 if (remaining_words > 0) {
2467 len = UniStrnlen((wchar_t *)bcc_ptr,
2469 kfree(ses->serverNOS);
2470 ses->serverNOS = kzalloc(2 * (len + 1),
2472 if (ses->serverNOS == NULL)
2473 goto sesssetup_nomem;
2474 cifs_strfromUCS_le(ses->serverNOS,
2477 bcc_ptr += 2 * (len + 1);
2478 ses->serverNOS[2 * len] = 0;
2479 ses->serverNOS[1 + (2 * len)] = 0;
2480 if (strncmp(ses->serverNOS,
2481 "NT LAN Manager 4", 16) == 0) {
2482 cFYI(1, ("NT4 server"));
2483 ses->flags |= CIFS_SES_NT4;
2485 remaining_words -= len + 1;
2486 if (remaining_words > 0) {
2487 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2488 /* last string is not always null terminated
2489 (for e.g. for Windows XP & 2000) */
2490 if (ses->serverDomain)
2491 kfree(ses->serverDomain);
2495 if (ses->serverDomain == NULL)
2496 goto sesssetup_nomem;
2497 cifs_strfromUCS_le(ses->serverDomain,
2500 bcc_ptr += 2 * (len + 1);
2501 ses->serverDomain[2*len] = 0;
2502 ses->serverDomain[1+(2*len)] = 0;
2503 } else { /* else no more room so create
2504 dummy domain string */
2505 if (ses->serverDomain)
2506 kfree(ses->serverDomain);
2508 kzalloc(2, GFP_KERNEL);
2510 } else { /* no room so create dummy domain
2513 /* if these kcallocs fail not much we
2514 can do, but better to not fail the
2516 kfree(ses->serverDomain);
2518 kzalloc(2, GFP_KERNEL);
2519 kfree(ses->serverNOS);
2521 kzalloc(2, GFP_KERNEL);
2523 } else { /* ASCII */
2524 len = strnlen(bcc_ptr, 1024);
2525 if (((long) bcc_ptr + len) - (long)
2526 pByteArea(smb_buffer_response)
2527 <= BCC(smb_buffer_response)) {
2528 kfree(ses->serverOS);
2529 ses->serverOS = kzalloc(len + 1,
2531 if (ses->serverOS == NULL)
2532 goto sesssetup_nomem;
2533 strncpy(ses->serverOS, bcc_ptr, len);
2536 /* null terminate the string */
2540 len = strnlen(bcc_ptr, 1024);
2541 kfree(ses->serverNOS);
2542 ses->serverNOS = kzalloc(len + 1,
2544 if (ses->serverNOS == NULL)
2545 goto sesssetup_nomem;
2546 strncpy(ses->serverNOS, bcc_ptr, len);
2551 len = strnlen(bcc_ptr, 1024);
2552 if (ses->serverDomain)
2553 kfree(ses->serverDomain);
2554 ses->serverDomain = kzalloc(len + 1,
2556 if (ses->serverDomain == NULL)
2557 goto sesssetup_nomem;
2558 strncpy(ses->serverDomain, bcc_ptr,
2565 ("Variable field of length %d "
2566 "extends beyond end of smb ",
2571 (" Security Blob Length extends beyond "
2576 (" Invalid Word count %d: ",
2577 smb_buffer_response->WordCount));
2580 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2581 since that could make reconnection harder, and
2582 reconnection might be needed to free memory */
2583 cifs_buf_release(smb_buffer);
2589 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2590 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2591 const struct nls_table *nls_codepage)
2593 struct smb_hdr *smb_buffer;
2594 struct smb_hdr *smb_buffer_response;
2595 SESSION_SETUP_ANDX *pSMB;
2596 SESSION_SETUP_ANDX *pSMBr;
2600 int remaining_words = 0;
2601 int bytes_returned = 0;
2603 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2604 PNEGOTIATE_MESSAGE SecurityBlob;
2605 PCHALLENGE_MESSAGE SecurityBlob2;
2606 __u32 negotiate_flags, capabilities;
2609 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2612 domain = ses->domainName;
2613 *pNTLMv2_flag = false;
2614 smb_buffer = cifs_buf_get();
2615 if (smb_buffer == NULL) {
2618 smb_buffer_response = smb_buffer;
2619 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2620 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2622 /* send SMBsessionSetup here */
2623 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2624 NULL /* no tCon exists yet */ , 12 /* wct */ );
2626 smb_buffer->Mid = GetNextMid(ses->server);
2627 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2628 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2630 pSMB->req.AndXCommand = 0xFF;
2631 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2632 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2634 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2635 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2637 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2638 CAP_EXTENDED_SECURITY;
2639 if (ses->capabilities & CAP_UNICODE) {
2640 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2641 capabilities |= CAP_UNICODE;
2643 if (ses->capabilities & CAP_STATUS32) {
2644 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2645 capabilities |= CAP_STATUS32;
2647 if (ses->capabilities & CAP_DFS) {
2648 smb_buffer->Flags2 |= SMBFLG2_DFS;
2649 capabilities |= CAP_DFS;
2651 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2653 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2654 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2655 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2656 SecurityBlob->MessageType = NtLmNegotiate;
2658 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2659 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2660 NTLMSSP_NEGOTIATE_56 |
2661 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2663 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2664 /* if (ntlmv2_support)
2665 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2666 /* setup pointers to domain name and workstation name */
2667 bcc_ptr += SecurityBlobLength;
2669 SecurityBlob->WorkstationName.Buffer = 0;
2670 SecurityBlob->WorkstationName.Length = 0;
2671 SecurityBlob->WorkstationName.MaximumLength = 0;
2673 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2674 along with username on auth request (ie the response to challenge) */
2675 SecurityBlob->DomainName.Buffer = 0;
2676 SecurityBlob->DomainName.Length = 0;
2677 SecurityBlob->DomainName.MaximumLength = 0;
2678 if (ses->capabilities & CAP_UNICODE) {
2679 if ((long) bcc_ptr % 2) {
2685 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2687 bcc_ptr += 2 * bytes_returned;
2689 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2691 bcc_ptr += 2 * bytes_returned;
2692 bcc_ptr += 2; /* null terminate Linux version */
2694 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2696 bcc_ptr += 2 * bytes_returned;
2699 bcc_ptr += 2; /* null terminate network opsys string */
2702 bcc_ptr += 2; /* null domain */
2703 } else { /* ASCII */
2704 strcpy(bcc_ptr, "Linux version ");
2705 bcc_ptr += strlen("Linux version ");
2706 strcpy(bcc_ptr, utsname()->release);
2707 bcc_ptr += strlen(utsname()->release) + 1;
2708 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2709 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2710 bcc_ptr++; /* empty domain field */
2713 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2714 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2715 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2716 smb_buffer->smb_buf_length += count;
2717 pSMB->req.ByteCount = cpu_to_le16(count);
2719 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2720 &bytes_returned, CIFS_LONG_OP);
2722 if (smb_buffer_response->Status.CifsError ==
2723 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2727 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2728 } else if ((smb_buffer_response->WordCount == 3)
2729 || (smb_buffer_response->WordCount == 4)) {
2730 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2731 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2733 if (action & GUEST_LOGIN)
2734 cFYI(1, (" Guest login"));
2735 /* Do we want to set anything in SesInfo struct when guest login? */
2737 bcc_ptr = pByteArea(smb_buffer_response);
2738 /* response can have either 3 or 4 word count - Samba sends 3 */
2740 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2741 if (SecurityBlob2->MessageType != NtLmChallenge) {
2743 ("Unexpected NTLMSSP message type received %d",
2744 SecurityBlob2->MessageType));
2746 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2747 cFYI(1, ("UID = %d", ses->Suid));
2748 if ((pSMBr->resp.hdr.WordCount == 3)
2749 || ((pSMBr->resp.hdr.WordCount == 4)
2751 pSMBr->resp.ByteCount))) {
2753 if (pSMBr->resp.hdr.WordCount == 4) {
2754 bcc_ptr += blob_len;
2755 cFYI(1, ("Security Blob Length %d",
2759 cFYI(1, ("NTLMSSP Challenge rcvd"));
2761 memcpy(ses->server->cryptKey,
2762 SecurityBlob2->Challenge,
2763 CIFS_CRYPTO_KEY_SIZE);
2764 if (SecurityBlob2->NegotiateFlags &
2765 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2766 *pNTLMv2_flag = true;
2768 if ((SecurityBlob2->NegotiateFlags &
2769 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2770 || (sign_CIFS_PDUs > 1))
2771 ses->server->secMode |=
2772 SECMODE_SIGN_REQUIRED;
2773 if ((SecurityBlob2->NegotiateFlags &
2774 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2775 ses->server->secMode |=
2776 SECMODE_SIGN_ENABLED;
2778 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2779 if ((long) (bcc_ptr) % 2) {
2781 (BCC(smb_buffer_response)
2783 /* Must word align unicode strings */
2788 (smb_buffer_response) / 2;
2791 UniStrnlen((wchar_t *) bcc_ptr,
2792 remaining_words - 1);
2793 /* We look for obvious messed up bcc or strings in response so we do not go off
2794 the end since (at least) WIN2K and Windows XP have a major bug in not null
2795 terminating last Unicode string in response */
2797 kfree(ses->serverOS);
2799 kzalloc(2 * (len + 1), GFP_KERNEL);
2800 cifs_strfromUCS_le(ses->serverOS,
2804 bcc_ptr += 2 * (len + 1);
2805 remaining_words -= len + 1;
2806 ses->serverOS[2 * len] = 0;
2807 ses->serverOS[1 + (2 * len)] = 0;
2808 if (remaining_words > 0) {
2809 len = UniStrnlen((wchar_t *)
2813 kfree(ses->serverNOS);
2815 kzalloc(2 * (len + 1),
2817 cifs_strfromUCS_le(ses->
2823 bcc_ptr += 2 * (len + 1);
2824 ses->serverNOS[2 * len] = 0;
2827 remaining_words -= len + 1;
2828 if (remaining_words > 0) {
2829 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2830 /* last string not always null terminated
2831 (for e.g. for Windows XP & 2000) */
2832 kfree(ses->serverDomain);
2844 ses->serverDomain[2*len]
2849 } /* else no more room so create dummy domain string */
2851 kfree(ses->serverDomain);
2856 } else { /* no room so create dummy domain and NOS string */
2857 kfree(ses->serverDomain);
2859 kzalloc(2, GFP_KERNEL);
2860 kfree(ses->serverNOS);
2862 kzalloc(2, GFP_KERNEL);
2864 } else { /* ASCII */
2865 len = strnlen(bcc_ptr, 1024);
2866 if (((long) bcc_ptr + len) - (long)
2867 pByteArea(smb_buffer_response)
2868 <= BCC(smb_buffer_response)) {
2870 kfree(ses->serverOS);
2874 strncpy(ses->serverOS,
2878 bcc_ptr[0] = 0; /* null terminate string */
2881 len = strnlen(bcc_ptr, 1024);
2882 kfree(ses->serverNOS);
2886 strncpy(ses->serverNOS, bcc_ptr, len);
2891 len = strnlen(bcc_ptr, 1024);
2892 kfree(ses->serverDomain);
2896 strncpy(ses->serverDomain,
2903 ("field of length %d "
2904 "extends beyond end of smb",
2908 cERROR(1, ("Security Blob Length extends beyond"
2912 cERROR(1, ("No session structure passed in."));
2916 (" Invalid Word count %d:",
2917 smb_buffer_response->WordCount));
2921 cifs_buf_release(smb_buffer);
2926 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2927 char *ntlm_session_key, bool ntlmv2_flag,
2928 const struct nls_table *nls_codepage)
2930 struct smb_hdr *smb_buffer;
2931 struct smb_hdr *smb_buffer_response;
2932 SESSION_SETUP_ANDX *pSMB;
2933 SESSION_SETUP_ANDX *pSMBr;
2938 int remaining_words = 0;
2939 int bytes_returned = 0;
2941 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2942 PAUTHENTICATE_MESSAGE SecurityBlob;
2943 __u32 negotiate_flags, capabilities;
2946 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2949 user = ses->userName;
2950 domain = ses->domainName;
2951 smb_buffer = cifs_buf_get();
2952 if (smb_buffer == NULL) {
2955 smb_buffer_response = smb_buffer;
2956 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2957 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2959 /* send SMBsessionSetup here */
2960 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2961 NULL /* no tCon exists yet */ , 12 /* wct */ );
2963 smb_buffer->Mid = GetNextMid(ses->server);
2964 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2965 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2966 pSMB->req.AndXCommand = 0xFF;
2967 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2968 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2970 pSMB->req.hdr.Uid = ses->Suid;
2972 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2973 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2975 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2976 CAP_EXTENDED_SECURITY;
2977 if (ses->capabilities & CAP_UNICODE) {
2978 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2979 capabilities |= CAP_UNICODE;
2981 if (ses->capabilities & CAP_STATUS32) {
2982 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2983 capabilities |= CAP_STATUS32;
2985 if (ses->capabilities & CAP_DFS) {
2986 smb_buffer->Flags2 |= SMBFLG2_DFS;
2987 capabilities |= CAP_DFS;
2989 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2991 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
2992 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
2993 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2994 SecurityBlob->MessageType = NtLmAuthenticate;
2995 bcc_ptr += SecurityBlobLength;
2996 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
2997 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
2998 0x80000000 | NTLMSSP_NEGOTIATE_128;
3000 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3002 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3004 /* setup pointers to domain name and workstation name */
3006 SecurityBlob->WorkstationName.Buffer = 0;
3007 SecurityBlob->WorkstationName.Length = 0;
3008 SecurityBlob->WorkstationName.MaximumLength = 0;
3009 SecurityBlob->SessionKey.Length = 0;
3010 SecurityBlob->SessionKey.MaximumLength = 0;
3011 SecurityBlob->SessionKey.Buffer = 0;
3013 SecurityBlob->LmChallengeResponse.Length = 0;
3014 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3015 SecurityBlob->LmChallengeResponse.Buffer = 0;
3017 SecurityBlob->NtChallengeResponse.Length =
3018 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3019 SecurityBlob->NtChallengeResponse.MaximumLength =
3020 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3021 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3022 SecurityBlob->NtChallengeResponse.Buffer =
3023 cpu_to_le32(SecurityBlobLength);
3024 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3025 bcc_ptr += CIFS_SESS_KEY_SIZE;
3027 if (ses->capabilities & CAP_UNICODE) {
3028 if (domain == NULL) {
3029 SecurityBlob->DomainName.Buffer = 0;
3030 SecurityBlob->DomainName.Length = 0;
3031 SecurityBlob->DomainName.MaximumLength = 0;
3033 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3036 SecurityBlob->DomainName.MaximumLength =
3038 SecurityBlob->DomainName.Buffer =
3039 cpu_to_le32(SecurityBlobLength);
3041 SecurityBlobLength += ln;
3042 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3045 SecurityBlob->UserName.Buffer = 0;
3046 SecurityBlob->UserName.Length = 0;
3047 SecurityBlob->UserName.MaximumLength = 0;
3049 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3052 SecurityBlob->UserName.MaximumLength =
3054 SecurityBlob->UserName.Buffer =
3055 cpu_to_le32(SecurityBlobLength);
3057 SecurityBlobLength += ln;
3058 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3061 /* SecurityBlob->WorkstationName.Length =
3062 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3063 SecurityBlob->WorkstationName.Length *= 2;
3064 SecurityBlob->WorkstationName.MaximumLength =
3065 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3066 SecurityBlob->WorkstationName.Buffer =
3067 cpu_to_le32(SecurityBlobLength);
3068 bcc_ptr += SecurityBlob->WorkstationName.Length;
3069 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3070 SecurityBlob->WorkstationName.Length =
3071 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3073 if ((long) bcc_ptr % 2) {
3078 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3080 bcc_ptr += 2 * bytes_returned;
3082 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3084 bcc_ptr += 2 * bytes_returned;
3085 bcc_ptr += 2; /* null term version string */
3087 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3089 bcc_ptr += 2 * bytes_returned;
3092 bcc_ptr += 2; /* null terminate network opsys string */
3095 bcc_ptr += 2; /* null domain */
3096 } else { /* ASCII */
3097 if (domain == NULL) {
3098 SecurityBlob->DomainName.Buffer = 0;
3099 SecurityBlob->DomainName.Length = 0;
3100 SecurityBlob->DomainName.MaximumLength = 0;
3103 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3104 strncpy(bcc_ptr, domain, 63);
3105 ln = strnlen(domain, 64);
3106 SecurityBlob->DomainName.MaximumLength =
3108 SecurityBlob->DomainName.Buffer =
3109 cpu_to_le32(SecurityBlobLength);
3111 SecurityBlobLength += ln;
3112 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3115 SecurityBlob->UserName.Buffer = 0;
3116 SecurityBlob->UserName.Length = 0;
3117 SecurityBlob->UserName.MaximumLength = 0;
3120 strncpy(bcc_ptr, user, 63);
3121 ln = strnlen(user, 64);
3122 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3123 SecurityBlob->UserName.Buffer =
3124 cpu_to_le32(SecurityBlobLength);
3126 SecurityBlobLength += ln;
3127 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3129 /* BB fill in our workstation name if known BB */
3131 strcpy(bcc_ptr, "Linux version ");
3132 bcc_ptr += strlen("Linux version ");
3133 strcpy(bcc_ptr, utsname()->release);
3134 bcc_ptr += strlen(utsname()->release) + 1;
3135 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3136 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3137 bcc_ptr++; /* null domain */
3140 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3141 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3142 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3143 smb_buffer->smb_buf_length += count;
3144 pSMB->req.ByteCount = cpu_to_le16(count);
3146 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3147 &bytes_returned, CIFS_LONG_OP);
3149 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3150 } else if ((smb_buffer_response->WordCount == 3) ||
3151 (smb_buffer_response->WordCount == 4)) {
3152 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3153 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3154 if (action & GUEST_LOGIN)
3155 cFYI(1, (" Guest login")); /* BB Should we set anything
3156 in SesInfo struct ? */
3157 /* if (SecurityBlob2->MessageType != NtLm??) {
3158 cFYI("Unexpected message type on auth response is %d"));
3163 ("Check challenge UID %d vs auth response UID %d",
3164 ses->Suid, smb_buffer_response->Uid));
3165 /* UID left in wire format */
3166 ses->Suid = smb_buffer_response->Uid;
3167 bcc_ptr = pByteArea(smb_buffer_response);
3168 /* response can have either 3 or 4 word count - Samba sends 3 */
3169 if ((pSMBr->resp.hdr.WordCount == 3)
3170 || ((pSMBr->resp.hdr.WordCount == 4)
3172 pSMBr->resp.ByteCount))) {
3173 if (pSMBr->resp.hdr.WordCount == 4) {
3177 ("Security Blob Length %d ",
3182 ("NTLMSSP response to Authenticate "));
3184 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3185 if ((long) (bcc_ptr) % 2) {
3187 (BCC(smb_buffer_response)
3189 bcc_ptr++; /* Unicode strings must be word aligned */
3191 remaining_words = BCC(smb_buffer_response) / 2;
3193 len = UniStrnlen((wchar_t *) bcc_ptr,
3194 remaining_words - 1);
3195 /* We look for obvious messed up bcc or strings in response so we do not go off
3196 the end since (at least) WIN2K and Windows XP have a major bug in not null
3197 terminating last Unicode string in response */
3199 kfree(ses->serverOS);
3201 kzalloc(2 * (len + 1), GFP_KERNEL);
3202 cifs_strfromUCS_le(ses->serverOS,
3206 bcc_ptr += 2 * (len + 1);
3207 remaining_words -= len + 1;
3208 ses->serverOS[2 * len] = 0;
3209 ses->serverOS[1 + (2 * len)] = 0;
3210 if (remaining_words > 0) {
3211 len = UniStrnlen((wchar_t *)
3215 kfree(ses->serverNOS);
3217 kzalloc(2 * (len + 1),
3219 cifs_strfromUCS_le(ses->
3225 bcc_ptr += 2 * (len + 1);
3226 ses->serverNOS[2 * len] = 0;
3227 ses->serverNOS[1+(2*len)] = 0;
3228 remaining_words -= len + 1;
3229 if (remaining_words > 0) {
3230 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3231 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3232 if (ses->serverDomain)
3233 kfree(ses->serverDomain);
3258 } /* else no more room so create dummy domain string */
3260 if (ses->serverDomain)
3261 kfree(ses->serverDomain);
3262 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3264 } else { /* no room so create dummy domain and NOS string */
3265 if (ses->serverDomain)
3266 kfree(ses->serverDomain);
3267 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3268 kfree(ses->serverNOS);
3269 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3271 } else { /* ASCII */
3272 len = strnlen(bcc_ptr, 1024);
3273 if (((long) bcc_ptr + len) -
3274 (long) pByteArea(smb_buffer_response)
3275 <= BCC(smb_buffer_response)) {
3277 kfree(ses->serverOS);
3278 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3279 strncpy(ses->serverOS,bcc_ptr, len);
3282 bcc_ptr[0] = 0; /* null terminate the string */
3285 len = strnlen(bcc_ptr, 1024);
3286 kfree(ses->serverNOS);
3287 ses->serverNOS = kzalloc(len+1,
3289 strncpy(ses->serverNOS,
3295 len = strnlen(bcc_ptr, 1024);
3296 if (ses->serverDomain)
3297 kfree(ses->serverDomain);
3301 strncpy(ses->serverDomain,
3307 cFYI(1, ("field of length %d "
3308 "extends beyond end of smb ",
3312 cERROR(1, ("Security Blob extends beyond end "
3316 cERROR(1, ("No session structure passed in."));
3319 cERROR(1, ("Invalid Word count %d: ",
3320 smb_buffer_response->WordCount));
3324 cifs_buf_release(smb_buffer);
3330 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3331 const char *tree, struct cifsTconInfo *tcon,
3332 const struct nls_table *nls_codepage)
3334 struct smb_hdr *smb_buffer;
3335 struct smb_hdr *smb_buffer_response;
3338 unsigned char *bcc_ptr;
3346 smb_buffer = cifs_buf_get();
3347 if (smb_buffer == NULL) {
3350 smb_buffer_response = smb_buffer;
3352 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3353 NULL /*no tid */ , 4 /*wct */ );
3355 smb_buffer->Mid = GetNextMid(ses->server);
3356 smb_buffer->Uid = ses->Suid;
3357 pSMB = (TCONX_REQ *) smb_buffer;
3358 pSMBr = (TCONX_RSP *) smb_buffer_response;
3360 pSMB->AndXCommand = 0xFF;
3361 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3362 bcc_ptr = &pSMB->Password[0];
3363 if ((ses->server->secMode) & SECMODE_USER) {
3364 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3365 *bcc_ptr = 0; /* password is null byte */
3366 bcc_ptr++; /* skip password */
3367 /* already aligned so no need to do it below */
3369 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3370 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3371 specified as required (when that support is added to
3372 the vfs in the future) as only NTLM or the much
3373 weaker LANMAN (which we do not send by default) is accepted
3374 by Samba (not sure whether other servers allow
3375 NTLMv2 password here) */
3376 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3377 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3378 (ses->server->secType == LANMAN))
3379 calc_lanman_hash(ses, bcc_ptr);
3381 #endif /* CIFS_WEAK_PW_HASH */
3382 SMBNTencrypt(ses->password,
3383 ses->server->cryptKey,
3386 bcc_ptr += CIFS_SESS_KEY_SIZE;
3387 if (ses->capabilities & CAP_UNICODE) {
3388 /* must align unicode strings */
3389 *bcc_ptr = 0; /* null byte password */
3394 if (ses->server->secMode &
3395 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3396 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3398 if (ses->capabilities & CAP_STATUS32) {
3399 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3401 if (ses->capabilities & CAP_DFS) {
3402 smb_buffer->Flags2 |= SMBFLG2_DFS;
3404 if (ses->capabilities & CAP_UNICODE) {
3405 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3407 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3408 6 /* max utf8 char length in bytes */ *
3409 (/* server len*/ + 256 /* share len */), nls_codepage);
3410 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3411 bcc_ptr += 2; /* skip trailing null */
3412 } else { /* ASCII */
3413 strcpy(bcc_ptr, tree);
3414 bcc_ptr += strlen(tree) + 1;
3416 strcpy(bcc_ptr, "?????");
3417 bcc_ptr += strlen("?????");
3419 count = bcc_ptr - &pSMB->Password[0];
3420 pSMB->hdr.smb_buf_length += count;
3421 pSMB->ByteCount = cpu_to_le16(count);
3423 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3426 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3427 /* above now done in SendReceive */
3428 if ((rc == 0) && (tcon != NULL)) {
3429 tcon->tidStatus = CifsGood;
3430 tcon->tid = smb_buffer_response->Tid;
3431 bcc_ptr = pByteArea(smb_buffer_response);
3432 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3433 /* skip service field (NB: this field is always ASCII) */
3435 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3436 (bcc_ptr[2] == 'C')) {
3437 cFYI(1, ("IPC connection"));
3440 } else if (length == 2) {
3441 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3442 /* the most common case */
3443 cFYI(1, ("disk share connection"));
3446 bcc_ptr += length + 1;
3447 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3448 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3449 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3450 if ((bcc_ptr + (2 * length)) -
3451 pByteArea(smb_buffer_response) <=
3452 BCC(smb_buffer_response)) {
3453 kfree(tcon->nativeFileSystem);
3454 tcon->nativeFileSystem =
3455 kzalloc(length + 2, GFP_KERNEL);
3456 if (tcon->nativeFileSystem)
3458 tcon->nativeFileSystem,
3460 length, nls_codepage);
3461 bcc_ptr += 2 * length;
3462 bcc_ptr[0] = 0; /* null terminate the string */
3466 /* else do not bother copying these information fields*/
3468 length = strnlen(bcc_ptr, 1024);
3469 if ((bcc_ptr + length) -
3470 pByteArea(smb_buffer_response) <=
3471 BCC(smb_buffer_response)) {
3472 kfree(tcon->nativeFileSystem);
3473 tcon->nativeFileSystem =
3474 kzalloc(length + 1, GFP_KERNEL);
3475 if (tcon->nativeFileSystem)
3476 strncpy(tcon->nativeFileSystem, bcc_ptr,
3479 /* else do not bother copying these information fields*/
3481 if ((smb_buffer_response->WordCount == 3) ||
3482 (smb_buffer_response->WordCount == 7))
3483 /* field is in same location */
3484 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3487 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3488 } else if ((rc == 0) && tcon == NULL) {
3489 /* all we need to save for IPC$ connection */
3490 ses->ipc_tid = smb_buffer_response->Tid;
3493 cifs_buf_release(smb_buffer);
3498 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3502 struct cifsSesInfo *ses = NULL;
3503 struct task_struct *cifsd_task;
3508 if (cifs_sb->tcon) {
3509 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3510 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3515 DeleteTconOplockQEntries(cifs_sb->tcon);
3516 tconInfoFree(cifs_sb->tcon);
3517 if ((ses) && (ses->server)) {
3518 /* save off task so we do not refer to ses later */
3519 cifsd_task = ses->server->tsk;
3520 cFYI(1, ("About to do SMBLogoff "));
3521 rc = CIFSSMBLogoff(xid, ses);
3525 } else if (rc == -ESHUTDOWN) {
3526 cFYI(1, ("Waking up socket by sending signal"));
3528 force_sig(SIGKILL, cifsd_task);
3529 kthread_stop(cifsd_task);
3532 } /* else - we have an smb session
3533 left on this socket do not kill cifsd */
3535 cFYI(1, ("No session or bad tcon"));
3538 cifs_sb->tcon = NULL;
3539 tmp = cifs_sb->prepath;
3540 cifs_sb->prepathlen = 0;
3541 cifs_sb->prepath = NULL;
3550 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3551 struct nls_table *nls_info)
3554 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3555 bool ntlmv2_flag = false;
3558 /* what if server changes its buffer size after dropping the session? */
3559 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3560 rc = CIFSSMBNegotiate(xid, pSesInfo);
3561 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3562 rc = CIFSSMBNegotiate(xid, pSesInfo);
3567 spin_lock(&GlobalMid_Lock);
3568 if (pSesInfo->server->tcpStatus != CifsExiting)
3569 pSesInfo->server->tcpStatus = CifsGood;
3572 spin_unlock(&GlobalMid_Lock);
3578 pSesInfo->flags = 0;
3579 pSesInfo->capabilities = pSesInfo->server->capabilities;
3580 if (linuxExtEnabled == 0)
3581 pSesInfo->capabilities &= (~CAP_UNIX);
3582 /* pSesInfo->sequence_number = 0;*/
3584 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3585 pSesInfo->server->secMode,
3586 pSesInfo->server->capabilities,
3587 pSesInfo->server->timeAdj));
3588 if (experimEnabled < 2)
3589 rc = CIFS_SessSetup(xid, pSesInfo,
3590 first_time, nls_info);
3591 else if (extended_security
3592 && (pSesInfo->capabilities
3593 & CAP_EXTENDED_SECURITY)
3594 && (pSesInfo->server->secType == NTLMSSP)) {
3596 } else if (extended_security
3597 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3598 && (pSesInfo->server->secType == RawNTLMSSP)) {
3599 cFYI(1, ("NTLMSSP sesssetup"));
3600 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3607 cFYI(1, ("more secure NTLM ver2 hash"));
3608 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3613 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3615 CalcNTLMv2_response(pSesInfo,
3618 cifs_calculate_ntlmv2_mac_key(
3619 pSesInfo->server->mac_signing_key,
3620 response, ntlm_session_key,*/
3622 /* BB Put dummy sig in SessSetup PDU? */
3629 SMBNTencrypt(pSesInfo->password,
3630 pSesInfo->server->cryptKey,
3634 cifs_calculate_mac_key(
3635 &pSesInfo->server->mac_signing_key,
3637 pSesInfo->password);
3639 /* for better security the weaker lanman hash not sent
3640 in AuthSessSetup so we no longer calculate it */
3642 rc = CIFSNTLMSSPAuthSessSetup(xid,
3648 } else { /* old style NTLM 0.12 session setup */
3649 SMBNTencrypt(pSesInfo->password,
3650 pSesInfo->server->cryptKey,
3654 cifs_calculate_mac_key(
3655 &pSesInfo->server->mac_signing_key,
3656 ntlm_session_key, pSesInfo->password);
3658 rc = CIFSSessSetup(xid, pSesInfo,
3659 ntlm_session_key, nls_info);
3662 cERROR(1, ("Send error in SessSetup = %d", rc));
3664 cFYI(1, ("CIFS Session Established successfully"));
3665 pSesInfo->status = CifsGood;