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 static DECLARE_COMPLETION(cifsd_complete);
54 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
57 extern mempool_t *cifs_req_poolp;
65 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[16]; /* netbios name of client */
68 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
81 bool no_psx_acl:1; /* set if posix acl support should be disabled */
83 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 bool server_ino:1; /* use inode numbers from server ie UniqueId */
86 bool remap:1; /* set to remap seven reserved chars in filenames */
87 bool posix_paths:1; /* unset to not ask for posix pathnames. */
90 bool nullauth:1; /* attempt to authenticate with null user */
91 unsigned nocase; /* request case insensitive filenames */
92 unsigned nobrl; /* disable sending byte range locks to srv */
96 unsigned short int port;
100 static int ipv4_connect(struct sockaddr_in *psin_server,
101 struct socket **csocket,
103 char *server_netb_name);
104 static int ipv6_connect(struct sockaddr_in6 *psin_server,
105 struct socket **csocket);
109 * cifs tcp session reconnection
111 * mark tcp session as reconnecting so temporarily locked
112 * mark all smb sessions as reconnecting for tcp session
113 * reconnect tcp session
114 * wake up waiters on reconnection? - (not needed currently)
118 cifs_reconnect(struct TCP_Server_Info *server)
121 struct list_head *tmp;
122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
124 struct mid_q_entry *mid_entry;
126 spin_lock(&GlobalMid_Lock);
127 if (kthread_should_stop()) {
128 /* the demux thread will exit normally
129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
137 cFYI(1, ("Reconnecting tcp session"));
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
141 read_lock(&GlobalSMBSeslock);
142 list_for_each(tmp, &GlobalSMBSessionList) {
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
145 if (ses->server == server) {
146 ses->status = CifsNeedReconnect;
150 /* else tcp and smb sessions need reconnection */
152 list_for_each(tmp, &GlobalTreeConnectionList) {
153 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
154 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
155 tcon->tidStatus = CifsNeedReconnect;
157 read_unlock(&GlobalSMBSeslock);
158 /* do not want to be sending data on a socket we are freeing */
159 down(&server->tcpSem);
160 if (server->ssocket) {
161 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
162 server->ssocket->flags));
163 kernel_sock_shutdown(server->ssocket, SHUT_WR);
164 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
165 server->ssocket->state,
166 server->ssocket->flags));
167 sock_release(server->ssocket);
168 server->ssocket = NULL;
171 spin_lock(&GlobalMid_Lock);
172 list_for_each(tmp, &server->pending_mid_q) {
173 mid_entry = list_entry(tmp, struct
177 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
178 /* Mark other intransit requests as needing
179 retry so we do not immediately mark the
180 session bad again (ie after we reconnect
181 below) as they timeout too */
182 mid_entry->midState = MID_RETRY_NEEDED;
186 spin_unlock(&GlobalMid_Lock);
189 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
191 if (server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,
195 rc = ipv4_connect(&server->addr.sockAddr,
197 server->workstation_RFC1001_name,
198 server->server_RFC1001_name);
201 cFYI(1, ("reconnect error %d", rc));
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
206 if (!kthread_should_stop())
207 server->tcpStatus = CifsGood;
208 server->sequence_number = 0;
209 spin_unlock(&GlobalMid_Lock);
210 /* atomic_set(&server->inFlight,0);*/
211 wake_up(&server->response_q);
219 0 not a transact2, or all data present
220 >0 transact2 with that much data missing
221 -EINVAL = invalid transact2
224 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
226 struct smb_t2_rsp *pSMBt;
228 int data_in_this_rsp;
231 if (pSMB->Command != SMB_COM_TRANSACTION2)
234 /* check for plausible wct, bcc and t2 data and parm sizes */
235 /* check for parm and data offset going beyond end of smb */
236 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
237 cFYI(1, ("invalid transact2 word count"));
241 pSMBt = (struct smb_t2_rsp *)pSMB;
243 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
244 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
246 remaining = total_data_size - data_in_this_rsp;
250 else if (remaining < 0) {
251 cFYI(1, ("total data %d smaller than data in frame %d",
252 total_data_size, data_in_this_rsp));
255 cFYI(1, ("missing %d bytes from transact2, check next response",
257 if (total_data_size > maxBufSize) {
258 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
259 total_data_size, maxBufSize));
266 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
268 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
269 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
274 char *data_area_of_target;
275 char *data_area_of_buf2;
278 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
280 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
281 cFYI(1, ("total data size of primary and secondary t2 differ"));
284 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
286 remaining = total_data_size - total_in_buf;
291 if (remaining == 0) /* nothing to do, ignore */
294 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
295 if (remaining < total_in_buf2) {
296 cFYI(1, ("transact2 2nd response contains too much data"));
299 /* find end of first SMB data area */
300 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
301 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
302 /* validate target area */
304 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
305 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
307 data_area_of_target += total_in_buf;
309 /* copy second buffer into end of first buffer */
310 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
311 total_in_buf += total_in_buf2;
312 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
313 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
314 byte_count += total_in_buf2;
315 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
317 byte_count = pTargetSMB->smb_buf_length;
318 byte_count += total_in_buf2;
320 /* BB also add check that we are not beyond maximum buffer size */
322 pTargetSMB->smb_buf_length = byte_count;
324 if (remaining == total_in_buf2) {
325 cFYI(1, ("found the last secondary response"));
326 return 0; /* we are done */
327 } else /* more responses to go */
333 cifs_demultiplex_thread(struct TCP_Server_Info *server)
336 unsigned int pdu_length, total_read;
337 struct smb_hdr *smb_buffer = NULL;
338 struct smb_hdr *bigbuf = NULL;
339 struct smb_hdr *smallbuf = NULL;
340 struct msghdr smb_msg;
342 struct socket *csocket = server->ssocket;
343 struct list_head *tmp;
344 struct cifsSesInfo *ses;
345 struct task_struct *task_to_wake = NULL;
346 struct mid_q_entry *mid_entry;
348 bool isLargeBuf = false;
352 current->flags |= PF_MEMALLOC;
353 server->tsk = current; /* save process info to wake at shutdown */
354 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
355 write_lock(&GlobalSMBSeslock);
356 atomic_inc(&tcpSesAllocCount);
357 length = tcpSesAllocCount.counter;
358 write_unlock(&GlobalSMBSeslock);
359 complete(&cifsd_complete);
361 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
365 while (!kthread_should_stop()) {
368 if (bigbuf == NULL) {
369 bigbuf = cifs_buf_get();
371 cERROR(1, ("No memory for large SMB response"));
373 /* retry will check if exiting */
376 } else if (isLargeBuf) {
377 /* we are reusing a dirty large buf, clear its start */
378 memset(bigbuf, 0, sizeof(struct smb_hdr));
381 if (smallbuf == NULL) {
382 smallbuf = cifs_small_buf_get();
384 cERROR(1, ("No memory for SMB response"));
386 /* retry will check if exiting */
389 /* beginning of smb buffer is cleared in our buf_get */
390 } else /* if existing small buf clear beginning */
391 memset(smallbuf, 0, sizeof(struct smb_hdr));
395 smb_buffer = smallbuf;
396 iov.iov_base = smb_buffer;
398 smb_msg.msg_control = NULL;
399 smb_msg.msg_controllen = 0;
400 pdu_length = 4; /* enough to get RFC1001 header */
403 kernel_recvmsg(csocket, &smb_msg,
404 &iov, 1, pdu_length, 0 /* BB other flags? */);
406 if (kthread_should_stop()) {
408 } else if (server->tcpStatus == CifsNeedReconnect) {
409 cFYI(1, ("Reconnect after server stopped responding"));
410 cifs_reconnect(server);
411 cFYI(1, ("call to reconnect done"));
412 csocket = server->ssocket;
414 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
415 msleep(1); /* minimum sleep to prevent looping
416 allowing socket to clear and app threads to set
417 tcpStatus CifsNeedReconnect if server hung */
422 } else if (length <= 0) {
423 if (server->tcpStatus == CifsNew) {
424 cFYI(1, ("tcp session abend after SMBnegprot"));
425 /* some servers kill the TCP session rather than
426 returning an SMB negprot error, in which
427 case reconnecting here is not going to help,
428 and so simply return error to mount */
431 if (!try_to_freeze() && (length == -EINTR)) {
432 cFYI(1, ("cifsd thread killed"));
435 cFYI(1, ("Reconnect after unexpected peek error %d",
437 cifs_reconnect(server);
438 csocket = server->ssocket;
439 wake_up(&server->response_q);
441 } else if (length < pdu_length) {
442 cFYI(1, ("requested %d bytes but only got %d bytes",
443 pdu_length, length));
444 pdu_length -= length;
449 /* The right amount was read from socket - 4 bytes */
450 /* so we can now interpret the length field */
452 /* the first byte big endian of the length field,
453 is actually not part of the length but the type
454 with the most common, zero, as regular data */
455 temp = *((char *) smb_buffer);
457 /* Note that FC 1001 length is big endian on the wire,
458 but we convert it here so it is always manipulated
459 as host byte order */
460 pdu_length = ntohl(smb_buffer->smb_buf_length);
461 smb_buffer->smb_buf_length = pdu_length;
463 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
465 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
467 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
468 cFYI(1, ("Good RFC 1002 session rsp"));
470 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
471 /* we get this from Windows 98 instead of
472 an error on SMB negprot response */
473 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
475 if (server->tcpStatus == CifsNew) {
476 /* if nack on negprot (rather than
477 ret of smb negprot error) reconnecting
478 not going to help, ret error to mount */
481 /* give server a second to
482 clean up before reconnect attempt */
484 /* always try 445 first on reconnect
485 since we get NACK on some if we ever
486 connected to port 139 (the NACK is
487 since we do not begin with RFC1001
488 session initialize frame) */
489 server->addr.sockAddr.sin_port =
491 cifs_reconnect(server);
492 csocket = server->ssocket;
493 wake_up(&server->response_q);
496 } else if (temp != (char) 0) {
497 cERROR(1, ("Unknown RFC 1002 frame"));
498 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
500 cifs_reconnect(server);
501 csocket = server->ssocket;
505 /* else we have an SMB response */
506 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
507 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
508 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
509 length, pdu_length+4));
510 cifs_reconnect(server);
511 csocket = server->ssocket;
512 wake_up(&server->response_q);
519 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
521 memcpy(bigbuf, smallbuf, 4);
525 iov.iov_base = 4 + (char *)smb_buffer;
526 iov.iov_len = pdu_length;
527 for (total_read = 0; total_read < pdu_length;
528 total_read += length) {
529 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
530 pdu_length - total_read, 0);
531 if (kthread_should_stop() ||
532 (length == -EINTR)) {
536 } else if (server->tcpStatus == CifsNeedReconnect) {
537 cifs_reconnect(server);
538 csocket = server->ssocket;
539 /* Reconnect wakes up rspns q */
540 /* Now we will reread sock */
543 } else if ((length == -ERESTARTSYS) ||
544 (length == -EAGAIN)) {
545 msleep(1); /* minimum sleep to prevent looping,
546 allowing socket to clear and app
547 threads to set tcpStatus
548 CifsNeedReconnect if server hung*/
551 } else if (length <= 0) {
552 cERROR(1, ("Received no data, expecting %d",
553 pdu_length - total_read));
554 cifs_reconnect(server);
555 csocket = server->ssocket;
562 else if (reconnect == 1)
565 length += 4; /* account for rfc1002 hdr */
568 dump_smb(smb_buffer, length);
569 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
570 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
576 spin_lock(&GlobalMid_Lock);
577 list_for_each(tmp, &server->pending_mid_q) {
578 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
580 if ((mid_entry->mid == smb_buffer->Mid) &&
581 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
582 (mid_entry->command == smb_buffer->Command)) {
583 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
584 /* We have a multipart transact2 resp */
586 if (mid_entry->resp_buf) {
587 /* merge response - fix up 1st*/
588 if (coalesce_t2(smb_buffer,
589 mid_entry->resp_buf)) {
590 mid_entry->multiRsp =
594 /* all parts received */
595 mid_entry->multiEnd =
601 cERROR(1,("1st trans2 resp needs bigbuf"));
602 /* BB maybe we can fix this up, switch
603 to already allocated large buffer? */
605 /* Have first buffer */
606 mid_entry->resp_buf =
608 mid_entry->largeBuf =
615 mid_entry->resp_buf = smb_buffer;
616 mid_entry->largeBuf = isLargeBuf;
618 task_to_wake = mid_entry->tsk;
619 mid_entry->midState = MID_RESPONSE_RECEIVED;
620 #ifdef CONFIG_CIFS_STATS2
621 mid_entry->when_received = jiffies;
623 /* so we do not time out requests to server
624 which is still responding (since server could
625 be busy but not dead) */
626 server->lstrp = jiffies;
630 spin_unlock(&GlobalMid_Lock);
632 /* Was previous buf put in mpx struct for multi-rsp? */
634 /* smb buffer will be freed by user thread */
640 wake_up_process(task_to_wake);
641 } else if (!is_valid_oplock_break(smb_buffer, server) &&
643 cERROR(1, ("No task to wake, unknown frame received! "
644 "NumMids %d", midCount.counter));
645 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
646 sizeof(struct smb_hdr));
647 #ifdef CONFIG_CIFS_DEBUG2
648 cifs_dump_detail(smb_buffer);
649 cifs_dump_mids(server);
650 #endif /* CIFS_DEBUG2 */
653 } /* end while !EXITING */
655 spin_lock(&GlobalMid_Lock);
656 server->tcpStatus = CifsExiting;
658 /* check if we have blocked requests that need to free */
659 /* Note that cifs_max_pending is normally 50, but
660 can be set at module install time to as little as two */
661 if (atomic_read(&server->inFlight) >= cifs_max_pending)
662 atomic_set(&server->inFlight, cifs_max_pending - 1);
663 /* We do not want to set the max_pending too low or we
664 could end up with the counter going negative */
665 spin_unlock(&GlobalMid_Lock);
666 /* Although there should not be any requests blocked on
667 this queue it can not hurt to be paranoid and try to wake up requests
668 that may haven been blocked when more than 50 at time were on the wire
669 to the same server - they now will see the session is in exit state
670 and get out of SendReceive. */
671 wake_up_all(&server->request_q);
672 /* give those requests time to exit */
675 if (server->ssocket) {
676 sock_release(csocket);
677 server->ssocket = NULL;
679 /* buffer usuallly freed in free_mid - need to free it here on exit */
680 cifs_buf_release(bigbuf);
681 if (smallbuf) /* no sense logging a debug message if NULL */
682 cifs_small_buf_release(smallbuf);
684 read_lock(&GlobalSMBSeslock);
685 if (list_empty(&server->pending_mid_q)) {
686 /* loop through server session structures attached to this and
688 list_for_each(tmp, &GlobalSMBSessionList) {
690 list_entry(tmp, struct cifsSesInfo,
692 if (ses->server == server) {
693 ses->status = CifsExiting;
697 read_unlock(&GlobalSMBSeslock);
699 /* although we can not zero the server struct pointer yet,
700 since there are active requests which may depnd on them,
701 mark the corresponding SMB sessions as exiting too */
702 list_for_each(tmp, &GlobalSMBSessionList) {
703 ses = list_entry(tmp, struct cifsSesInfo,
705 if (ses->server == server)
706 ses->status = CifsExiting;
709 spin_lock(&GlobalMid_Lock);
710 list_for_each(tmp, &server->pending_mid_q) {
711 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
712 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
713 cFYI(1, ("Clearing Mid 0x%x - waking up ",
715 task_to_wake = mid_entry->tsk;
717 wake_up_process(task_to_wake);
720 spin_unlock(&GlobalMid_Lock);
721 read_unlock(&GlobalSMBSeslock);
722 /* 1/8th of sec is more than enough time for them to exit */
726 if (!list_empty(&server->pending_mid_q)) {
727 /* mpx threads have not exited yet give them
728 at least the smb send timeout time for long ops */
729 /* due to delays on oplock break requests, we need
730 to wait at least 45 seconds before giving up
731 on a request getting a response and going ahead
733 cFYI(1, ("Wait for exit from demultiplex thread"));
735 /* if threads still have not exited they are probably never
736 coming home not much else we can do but free the memory */
739 write_lock(&GlobalSMBSeslock);
740 atomic_dec(&tcpSesAllocCount);
741 length = tcpSesAllocCount.counter;
743 /* last chance to mark ses pointers invalid
744 if there are any pointing to this (e.g
745 if a crazy root user tried to kill cifsd
746 kernel thread explicitly this might happen) */
747 list_for_each(tmp, &GlobalSMBSessionList) {
748 ses = list_entry(tmp, struct cifsSesInfo,
750 if (ses->server == server)
753 write_unlock(&GlobalSMBSeslock);
755 kfree(server->hostname);
758 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
764 /* extract the host portion of the UNC string */
766 extract_hostname(const char *unc)
772 /* skip double chars at beginning of string */
773 /* BB: check validity of these bytes? */
776 /* delimiter between hostname and sharename is always '\\' now */
777 delim = strchr(src, '\\');
779 return ERR_PTR(-EINVAL);
782 dst = kmalloc((len + 1), GFP_KERNEL);
784 return ERR_PTR(-ENOMEM);
786 memcpy(dst, src, len);
793 cifs_parse_mount_options(char *options, const char *devname,
798 unsigned int temp_len, i, j;
804 if (Local_System_Name[0] != 0)
805 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
807 char *nodename = utsname()->nodename;
808 int n = strnlen(nodename, 15);
809 memset(vol->source_rfc1001_name, 0x20, 15);
810 for (i = 0; i < n; i++) {
811 /* does not have to be perfect mapping since field is
812 informational, only used for servers that do not support
813 port 445 and it can be overridden at mount time */
814 vol->source_rfc1001_name[i] = toupper(nodename[i]);
817 vol->source_rfc1001_name[15] = 0;
818 /* null target name indicates to use *SMBSERVR default called name
819 if we end up sending RFC1001 session initialize */
820 vol->target_rfc1001_name[0] = 0;
821 vol->linux_uid = current->uid; /* current->euid instead? */
822 vol->linux_gid = current->gid;
823 vol->dir_mode = S_IRWXUGO;
824 /* 2767 perms indicate mandatory locking support */
825 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
827 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
829 /* default is always to request posix paths. */
830 vol->posix_paths = 1;
835 if (strncmp(options, "sep=", 4) == 0) {
836 if (options[4] != 0) {
837 separator[0] = options[4];
840 cFYI(1, ("Null separator not allowed"));
844 while ((data = strsep(&options, separator)) != NULL) {
847 if ((value = strchr(data, '=')) != NULL)
850 /* Have to parse this before we parse for "user" */
851 if (strnicmp(data, "user_xattr", 10) == 0) {
853 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
855 } else if (strnicmp(data, "user", 4) == 0) {
858 "CIFS: invalid or missing username\n");
859 return 1; /* needs_arg; */
860 } else if (!*value) {
861 /* null user, ie anonymous, authentication */
864 if (strnlen(value, 200) < 200) {
865 vol->username = value;
867 printk(KERN_WARNING "CIFS: username too long\n");
870 } else if (strnicmp(data, "pass", 4) == 0) {
872 vol->password = NULL;
874 } else if (value[0] == 0) {
875 /* check if string begins with double comma
876 since that would mean the password really
877 does start with a comma, and would not
878 indicate an empty string */
879 if (value[1] != separator[0]) {
880 vol->password = NULL;
884 temp_len = strlen(value);
885 /* removed password length check, NTLM passwords
886 can be arbitrarily long */
888 /* if comma in password, the string will be
889 prematurely null terminated. Commas in password are
890 specified across the cifs mount interface by a double
891 comma ie ,, and a comma used as in other cases ie ','
892 as a parameter delimiter/separator is single and due
893 to the strsep above is temporarily zeroed. */
895 /* NB: password legally can have multiple commas and
896 the only illegal character in a password is null */
898 if ((value[temp_len] == 0) &&
899 (value[temp_len+1] == separator[0])) {
901 value[temp_len] = separator[0];
902 temp_len += 2; /* move after second comma */
903 while (value[temp_len] != 0) {
904 if (value[temp_len] == separator[0]) {
905 if (value[temp_len+1] ==
907 /* skip second comma */
910 /* single comma indicating start
917 if (value[temp_len] == 0) {
921 /* point option to start of next parm */
922 options = value + temp_len + 1;
924 /* go from value to value + temp_len condensing
925 double commas to singles. Note that this ends up
926 allocating a few bytes too many, which is ok */
927 vol->password = kzalloc(temp_len, GFP_KERNEL);
928 if (vol->password == NULL) {
929 printk(KERN_WARNING "CIFS: no memory "
933 for (i = 0, j = 0; i < temp_len; i++, j++) {
934 vol->password[j] = value[i];
935 if (value[i] == separator[0]
936 && value[i+1] == separator[0]) {
937 /* skip second comma */
941 vol->password[j] = 0;
943 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
944 if (vol->password == NULL) {
945 printk(KERN_WARNING "CIFS: no memory "
949 strcpy(vol->password, value);
951 } else if (strnicmp(data, "ip", 2) == 0) {
952 if (!value || !*value) {
954 } else if (strnlen(value, 35) < 35) {
957 printk(KERN_WARNING "CIFS: ip address "
961 } else if (strnicmp(data, "sec", 3) == 0) {
962 if (!value || !*value) {
963 cERROR(1, ("no security value specified"));
965 } else if (strnicmp(value, "krb5i", 5) == 0) {
966 vol->secFlg |= CIFSSEC_MAY_KRB5 |
968 } else if (strnicmp(value, "krb5p", 5) == 0) {
969 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
971 cERROR(1, ("Krb5 cifs privacy not supported"));
973 } else if (strnicmp(value, "krb5", 4) == 0) {
974 vol->secFlg |= CIFSSEC_MAY_KRB5;
975 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
976 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
978 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
979 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
980 } else if (strnicmp(value, "ntlmi", 5) == 0) {
981 vol->secFlg |= CIFSSEC_MAY_NTLM |
983 } else if (strnicmp(value, "ntlm", 4) == 0) {
984 /* ntlm is default so can be turned off too */
985 vol->secFlg |= CIFSSEC_MAY_NTLM;
986 } else if (strnicmp(value, "nontlm", 6) == 0) {
987 /* BB is there a better way to do this? */
988 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
989 #ifdef CONFIG_CIFS_WEAK_PW_HASH
990 } else if (strnicmp(value, "lanman", 6) == 0) {
991 vol->secFlg |= CIFSSEC_MAY_LANMAN;
993 } else if (strnicmp(value, "none", 4) == 0) {
996 cERROR(1, ("bad security option: %s", value));
999 } else if ((strnicmp(data, "unc", 3) == 0)
1000 || (strnicmp(data, "target", 6) == 0)
1001 || (strnicmp(data, "path", 4) == 0)) {
1002 if (!value || !*value) {
1003 printk(KERN_WARNING "CIFS: invalid path to "
1004 "network resource\n");
1005 return 1; /* needs_arg; */
1007 if ((temp_len = strnlen(value, 300)) < 300) {
1008 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1009 if (vol->UNC == NULL)
1011 strcpy(vol->UNC, value);
1012 if (strncmp(vol->UNC, "//", 2) == 0) {
1015 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1017 "CIFS: UNC Path does not begin "
1018 "with // or \\\\ \n");
1022 printk(KERN_WARNING "CIFS: UNC name too long\n");
1025 } else if ((strnicmp(data, "domain", 3) == 0)
1026 || (strnicmp(data, "workgroup", 5) == 0)) {
1027 if (!value || !*value) {
1028 printk(KERN_WARNING "CIFS: invalid domain name\n");
1029 return 1; /* needs_arg; */
1031 /* BB are there cases in which a comma can be valid in
1032 a domain name and need special handling? */
1033 if (strnlen(value, 256) < 256) {
1034 vol->domainname = value;
1035 cFYI(1, ("Domain name set"));
1037 printk(KERN_WARNING "CIFS: domain name too "
1041 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1042 if (!value || !*value) {
1044 "CIFS: invalid path prefix\n");
1045 return 1; /* needs_argument */
1047 if ((temp_len = strnlen(value, 1024)) < 1024) {
1048 if (value[0] != '/')
1049 temp_len++; /* missing leading slash */
1050 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1051 if (vol->prepath == NULL)
1053 if (value[0] != '/') {
1054 vol->prepath[0] = '/';
1055 strcpy(vol->prepath+1, value);
1057 strcpy(vol->prepath, value);
1058 cFYI(1, ("prefix path %s", vol->prepath));
1060 printk(KERN_WARNING "CIFS: prefix too long\n");
1063 } else if (strnicmp(data, "iocharset", 9) == 0) {
1064 if (!value || !*value) {
1065 printk(KERN_WARNING "CIFS: invalid iocharset "
1067 return 1; /* needs_arg; */
1069 if (strnlen(value, 65) < 65) {
1070 if (strnicmp(value, "default", 7))
1071 vol->iocharset = value;
1072 /* if iocharset not set then load_nls_default
1073 is used by caller */
1074 cFYI(1, ("iocharset set to %s", value));
1076 printk(KERN_WARNING "CIFS: iocharset name "
1080 } else if (strnicmp(data, "uid", 3) == 0) {
1081 if (value && *value) {
1083 simple_strtoul(value, &value, 0);
1084 vol->override_uid = 1;
1086 } else if (strnicmp(data, "gid", 3) == 0) {
1087 if (value && *value) {
1089 simple_strtoul(value, &value, 0);
1090 vol->override_gid = 1;
1092 } else if (strnicmp(data, "file_mode", 4) == 0) {
1093 if (value && *value) {
1095 simple_strtoul(value, &value, 0);
1097 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1098 if (value && *value) {
1100 simple_strtoul(value, &value, 0);
1102 } else if (strnicmp(data, "dirmode", 4) == 0) {
1103 if (value && *value) {
1105 simple_strtoul(value, &value, 0);
1107 } else if (strnicmp(data, "port", 4) == 0) {
1108 if (value && *value) {
1110 simple_strtoul(value, &value, 0);
1112 } else if (strnicmp(data, "rsize", 5) == 0) {
1113 if (value && *value) {
1115 simple_strtoul(value, &value, 0);
1117 } else if (strnicmp(data, "wsize", 5) == 0) {
1118 if (value && *value) {
1120 simple_strtoul(value, &value, 0);
1122 } else if (strnicmp(data, "sockopt", 5) == 0) {
1123 if (value && *value) {
1125 simple_strtoul(value, &value, 0);
1127 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1128 if (!value || !*value || (*value == ' ')) {
1129 cFYI(1, ("invalid (empty) netbiosname"));
1131 memset(vol->source_rfc1001_name, 0x20, 15);
1132 for (i = 0; i < 15; i++) {
1133 /* BB are there cases in which a comma can be
1134 valid in this workstation netbios name (and need
1135 special handling)? */
1137 /* We do not uppercase netbiosname for user */
1141 vol->source_rfc1001_name[i] =
1144 /* The string has 16th byte zero still from
1145 set at top of the function */
1146 if ((i == 15) && (value[i] != 0))
1147 printk(KERN_WARNING "CIFS: netbiosname"
1148 " longer than 15 truncated.\n");
1150 } else if (strnicmp(data, "servern", 7) == 0) {
1151 /* servernetbiosname specified override *SMBSERVER */
1152 if (!value || !*value || (*value == ' ')) {
1153 cFYI(1, ("empty server netbiosname specified"));
1155 /* last byte, type, is 0x20 for servr type */
1156 memset(vol->target_rfc1001_name, 0x20, 16);
1158 for (i = 0; i < 15; i++) {
1159 /* BB are there cases in which a comma can be
1160 valid in this workstation netbios name
1161 (and need special handling)? */
1163 /* user or mount helper must uppercase
1168 vol->target_rfc1001_name[i] =
1171 /* The string has 16th byte zero still from
1172 set at top of the function */
1173 if ((i == 15) && (value[i] != 0))
1174 printk(KERN_WARNING "CIFS: server net"
1175 "biosname longer than 15 truncated.\n");
1177 } else if (strnicmp(data, "credentials", 4) == 0) {
1179 } else if (strnicmp(data, "version", 3) == 0) {
1181 } else if (strnicmp(data, "guest", 5) == 0) {
1183 } else if (strnicmp(data, "rw", 2) == 0) {
1185 } else if ((strnicmp(data, "suid", 4) == 0) ||
1186 (strnicmp(data, "nosuid", 6) == 0) ||
1187 (strnicmp(data, "exec", 4) == 0) ||
1188 (strnicmp(data, "noexec", 6) == 0) ||
1189 (strnicmp(data, "nodev", 5) == 0) ||
1190 (strnicmp(data, "noauto", 6) == 0) ||
1191 (strnicmp(data, "dev", 3) == 0)) {
1192 /* The mount tool or mount.cifs helper (if present)
1193 uses these opts to set flags, and the flags are read
1194 by the kernel vfs layer before we get here (ie
1195 before read super) so there is no point trying to
1196 parse these options again and set anything and it
1197 is ok to just ignore them */
1199 } else if (strnicmp(data, "ro", 2) == 0) {
1201 } else if (strnicmp(data, "hard", 4) == 0) {
1203 } else if (strnicmp(data, "soft", 4) == 0) {
1205 } else if (strnicmp(data, "perm", 4) == 0) {
1207 } else if (strnicmp(data, "noperm", 6) == 0) {
1209 } else if (strnicmp(data, "mapchars", 8) == 0) {
1211 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1213 } else if (strnicmp(data, "sfu", 3) == 0) {
1215 } else if (strnicmp(data, "nosfu", 5) == 0) {
1217 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1218 vol->posix_paths = 1;
1219 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1220 vol->posix_paths = 0;
1221 } else if (strnicmp(data, "nounix", 6) == 0) {
1222 vol->no_linux_ext = 1;
1223 } else if (strnicmp(data, "nolinux", 7) == 0) {
1224 vol->no_linux_ext = 1;
1225 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1226 (strnicmp(data, "ignorecase", 10) == 0)) {
1228 } else if (strnicmp(data, "brl", 3) == 0) {
1230 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1231 (strnicmp(data, "nolock", 6) == 0)) {
1233 /* turn off mandatory locking in mode
1234 if remote locking is turned off since the
1235 local vfs will do advisory */
1236 if (vol->file_mode ==
1237 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1238 vol->file_mode = S_IALLUGO;
1239 } else if (strnicmp(data, "setuids", 7) == 0) {
1241 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1243 } else if (strnicmp(data, "nohard", 6) == 0) {
1245 } else if (strnicmp(data, "nosoft", 6) == 0) {
1247 } else if (strnicmp(data, "nointr", 6) == 0) {
1249 } else if (strnicmp(data, "intr", 4) == 0) {
1251 } else if (strnicmp(data, "serverino", 7) == 0) {
1252 vol->server_ino = 1;
1253 } else if (strnicmp(data, "noserverino", 9) == 0) {
1254 vol->server_ino = 0;
1255 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1257 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1259 } else if (strnicmp(data, "acl", 3) == 0) {
1260 vol->no_psx_acl = 0;
1261 } else if (strnicmp(data, "noacl", 5) == 0) {
1262 vol->no_psx_acl = 1;
1263 } else if (strnicmp(data, "sign", 4) == 0) {
1264 vol->secFlg |= CIFSSEC_MUST_SIGN;
1265 /* } else if (strnicmp(data, "seal",4) == 0) {
1266 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1267 } else if (strnicmp(data, "direct", 6) == 0) {
1269 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1271 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1272 if (!value || !*value) {
1273 vol->in6_addr = NULL;
1274 } else if (strnlen(value, 49) == 48) {
1275 vol->in6_addr = value;
1277 printk(KERN_WARNING "CIFS: ip v6 address not "
1278 "48 characters long\n");
1281 } else if (strnicmp(data, "noac", 4) == 0) {
1282 printk(KERN_WARNING "CIFS: Mount option noac not "
1283 "supported. Instead set "
1284 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1286 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1289 if (vol->UNC == NULL) {
1290 if (devname == NULL) {
1291 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1295 if ((temp_len = strnlen(devname, 300)) < 300) {
1296 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1297 if (vol->UNC == NULL)
1299 strcpy(vol->UNC, devname);
1300 if (strncmp(vol->UNC, "//", 2) == 0) {
1303 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1304 printk(KERN_WARNING "CIFS: UNC Path does not "
1305 "begin with // or \\\\ \n");
1309 printk(KERN_WARNING "CIFS: UNC name too long\n");
1313 if (vol->UNCip == NULL)
1314 vol->UNCip = &vol->UNC[2];
1319 static struct cifsSesInfo *
1320 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1321 struct in6_addr *target_ip6_addr,
1322 char *userName, struct TCP_Server_Info **psrvTcp)
1324 struct list_head *tmp;
1325 struct cifsSesInfo *ses;
1327 read_lock(&GlobalSMBSeslock);
1329 list_for_each(tmp, &GlobalSMBSessionList) {
1330 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1332 if ((target_ip_addr &&
1333 (ses->server->addr.sockAddr.sin_addr.s_addr
1334 == target_ip_addr->s_addr)) || (target_ip6_addr
1335 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1336 target_ip6_addr, sizeof(*target_ip6_addr)))) {
1337 /* BB lock server and tcp session and increment
1340 /* found a match on the TCP session */
1341 *psrvTcp = ses->server;
1343 /* BB check if reconnection needed */
1345 (ses->userName, userName,
1346 MAX_USERNAME_SIZE) == 0){
1347 read_unlock(&GlobalSMBSeslock);
1348 /* Found exact match on both TCP and
1354 /* else tcp and smb sessions need reconnection */
1356 read_unlock(&GlobalSMBSeslock);
1360 static struct cifsTconInfo *
1361 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1363 struct list_head *tmp;
1364 struct cifsTconInfo *tcon;
1367 read_lock(&GlobalSMBSeslock);
1369 list_for_each(tmp, &GlobalTreeConnectionList) {
1370 cFYI(1, ("Next tcon"));
1371 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1372 if (!tcon->ses || !tcon->ses->server)
1375 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1376 cFYI(1, ("old ip addr: %x == new ip %x ?",
1377 old_ip, new_target_ip_addr));
1379 if (old_ip != new_target_ip_addr)
1382 /* BB lock tcon, server, tcp session and increment use count? */
1383 /* found a match on the TCP session */
1384 /* BB check if reconnection needed */
1385 cFYI(1, ("IP match, old UNC: %s new: %s",
1386 tcon->treeName, uncName));
1388 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1391 cFYI(1, ("and old usr: %s new: %s",
1392 tcon->treeName, uncName));
1394 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1397 /* matched smb session (user name) */
1398 read_unlock(&GlobalSMBSeslock);
1402 read_unlock(&GlobalSMBSeslock);
1407 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1408 const char *old_path, const struct nls_table *nls_codepage,
1411 struct dfs_info3_param *referrals = NULL;
1412 unsigned int num_referrals;
1415 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
1416 &num_referrals, &referrals, remap);
1418 /* BB Add in code to: if valid refrl, if not ip address contact
1419 the helper that resolves tcp names, mount to it, try to
1420 tcon to it unmount it if fail */
1428 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1429 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1430 struct dfs_info3_param **preferrals, int remap)
1434 unsigned char *targetUNCs;
1436 *pnum_referrals = 0;
1439 if (pSesInfo->ipc_tid == 0) {
1440 temp_unc = kmalloc(2 /* for slashes */ +
1441 strnlen(pSesInfo->serverName,
1442 SERVER_NAME_LEN_WITH_NULL * 2)
1443 + 1 + 4 /* slash IPC$ */ + 2,
1445 if (temp_unc == NULL)
1449 strcpy(temp_unc + 2, pSesInfo->serverName);
1450 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1451 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1453 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1457 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
1458 pnum_referrals, nls_codepage, remap);
1459 /* BB map targetUNCs to dfs_info3 structures, here or
1460 in CIFSGetDFSRefer BB */
1465 /* See RFC1001 section 14 on representation of Netbios names */
1466 static void rfc1002mangle(char *target, char *source, unsigned int length)
1470 for (i = 0, j = 0; i < (length); i++) {
1471 /* mask a nibble at a time and encode */
1472 target[j] = 'A' + (0x0F & (source[i] >> 4));
1473 target[j+1] = 'A' + (0x0F & source[i]);
1481 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1482 char *netbios_name, char *target_name)
1486 __be16 orig_port = 0;
1488 if (*csocket == NULL) {
1489 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1490 IPPROTO_TCP, csocket);
1492 cERROR(1, ("Error %d creating socket", rc));
1496 /* BB other socket options to set KEEPALIVE, NODELAY? */
1497 cFYI(1, ("Socket created"));
1498 (*csocket)->sk->sk_allocation = GFP_NOFS;
1502 psin_server->sin_family = AF_INET;
1503 if (psin_server->sin_port) { /* user overrode default port */
1504 rc = (*csocket)->ops->connect(*csocket,
1505 (struct sockaddr *) psin_server,
1506 sizeof(struct sockaddr_in), 0);
1512 /* save original port so we can retry user specified port
1513 later if fall back ports fail this time */
1514 orig_port = psin_server->sin_port;
1516 /* do not retry on the same port we just failed on */
1517 if (psin_server->sin_port != htons(CIFS_PORT)) {
1518 psin_server->sin_port = htons(CIFS_PORT);
1520 rc = (*csocket)->ops->connect(*csocket,
1521 (struct sockaddr *) psin_server,
1522 sizeof(struct sockaddr_in), 0);
1528 psin_server->sin_port = htons(RFC1001_PORT);
1529 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1531 sizeof(struct sockaddr_in), 0);
1536 /* give up here - unless we want to retry on different
1537 protocol families some day */
1540 psin_server->sin_port = orig_port;
1541 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1542 sock_release(*csocket);
1546 /* Eventually check for other socket options to change from
1547 the default. sock_setsockopt not used because it expects
1548 user space buffer */
1549 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1550 (*csocket)->sk->sk_sndbuf,
1551 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1552 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1553 /* make the bufsizes depend on wsize/rsize and max requests */
1554 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1555 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1556 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1557 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1559 /* send RFC1001 sessinit */
1560 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1561 /* some servers require RFC1001 sessinit before sending
1562 negprot - BB check reconnection in case where second
1563 sessinit is sent but no second negprot */
1564 struct rfc1002_session_packet *ses_init_buf;
1565 struct smb_hdr *smb_buf;
1566 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1569 ses_init_buf->trailer.session_req.called_len = 32;
1570 if (target_name && (target_name[0] != 0)) {
1571 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1574 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1575 DEFAULT_CIFS_CALLED_NAME, 16);
1578 ses_init_buf->trailer.session_req.calling_len = 32;
1579 /* calling name ends in null (byte 16) from old smb
1581 if (netbios_name && (netbios_name[0] != 0)) {
1582 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1585 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1586 "LINUX_CIFS_CLNT", 16);
1588 ses_init_buf->trailer.session_req.scope1 = 0;
1589 ses_init_buf->trailer.session_req.scope2 = 0;
1590 smb_buf = (struct smb_hdr *)ses_init_buf;
1591 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1592 smb_buf->smb_buf_length = 0x81000044;
1593 rc = smb_send(*csocket, smb_buf, 0x44,
1594 (struct sockaddr *)psin_server);
1595 kfree(ses_init_buf);
1596 msleep(1); /* RFC1001 layer in at least one server
1597 requires very short break before negprot
1598 presumably because not expecting negprot
1599 to follow so fast. This is a simple
1600 solution that works without
1601 complicating the code and causes no
1602 significant slowing down on mount
1603 for everyone else */
1605 /* else the negprot may still work without this
1606 even though malloc failed */
1614 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1618 __be16 orig_port = 0;
1620 if (*csocket == NULL) {
1621 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1622 IPPROTO_TCP, csocket);
1624 cERROR(1, ("Error %d creating ipv6 socket", rc));
1628 /* BB other socket options to set KEEPALIVE, NODELAY? */
1629 cFYI(1, ("ipv6 Socket created"));
1630 (*csocket)->sk->sk_allocation = GFP_NOFS;
1634 psin_server->sin6_family = AF_INET6;
1636 if (psin_server->sin6_port) { /* user overrode default port */
1637 rc = (*csocket)->ops->connect(*csocket,
1638 (struct sockaddr *) psin_server,
1639 sizeof(struct sockaddr_in6), 0);
1645 /* save original port so we can retry user specified port
1646 later if fall back ports fail this time */
1648 orig_port = psin_server->sin6_port;
1649 /* do not retry on the same port we just failed on */
1650 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1651 psin_server->sin6_port = htons(CIFS_PORT);
1653 rc = (*csocket)->ops->connect(*csocket,
1654 (struct sockaddr *) psin_server,
1655 sizeof(struct sockaddr_in6), 0);
1661 psin_server->sin6_port = htons(RFC1001_PORT);
1662 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1663 psin_server, sizeof(struct sockaddr_in6), 0);
1668 /* give up here - unless we want to retry on different
1669 protocol families some day */
1672 psin_server->sin6_port = orig_port;
1673 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1674 sock_release(*csocket);
1678 /* Eventually check for other socket options to change from
1679 the default. sock_setsockopt not used because it expects
1680 user space buffer */
1681 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1686 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1687 struct super_block *sb, struct smb_vol *vol_info)
1689 /* if we are reconnecting then should we check to see if
1690 * any requested capabilities changed locally e.g. via
1691 * remount but we can not do much about it here
1692 * if they have (even if we could detect it by the following)
1693 * Perhaps we could add a backpointer to array of sb from tcon
1694 * or if we change to make all sb to same share the same
1695 * sb as NFS - then we only have one backpointer to sb.
1696 * What if we wanted to mount the server share twice once with
1697 * and once without posixacls or posix paths? */
1698 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1700 if (vol_info && vol_info->no_linux_ext) {
1701 tcon->fsUnixInfo.Capability = 0;
1702 tcon->unix_ext = 0; /* Unix Extensions disabled */
1703 cFYI(1, ("Linux protocol extensions disabled"));
1705 } else if (vol_info)
1706 tcon->unix_ext = 1; /* Unix Extensions supported */
1708 if (tcon->unix_ext == 0) {
1709 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1713 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1714 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1716 /* check for reconnect case in which we do not
1717 want to change the mount behavior if we can avoid it */
1718 if (vol_info == NULL) {
1719 /* turn off POSIX ACL and PATHNAMES if not set
1720 originally at mount time */
1721 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1722 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1723 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1724 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1725 cERROR(1, ("POSIXPATH support change"));
1726 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1727 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1728 cERROR(1, ("possible reconnect error"));
1730 ("server disabled POSIX path support"));
1734 cap &= CIFS_UNIX_CAP_MASK;
1735 if (vol_info && vol_info->no_psx_acl)
1736 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1737 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1738 cFYI(1, ("negotiated posix acl support"));
1740 sb->s_flags |= MS_POSIXACL;
1743 if (vol_info && vol_info->posix_paths == 0)
1744 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1745 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1746 cFYI(1, ("negotiate posix pathnames"));
1748 CIFS_SB(sb)->mnt_cifs_flags |=
1749 CIFS_MOUNT_POSIX_PATHS;
1752 /* We might be setting the path sep back to a different
1753 form if we are reconnecting and the server switched its
1754 posix path capability for this share */
1755 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1756 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1758 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1759 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1760 CIFS_SB(sb)->rsize = 127 * 1024;
1762 ("larger reads not supported by srv"));
1767 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1768 #ifdef CONFIG_CIFS_DEBUG2
1769 if (cap & CIFS_UNIX_FCNTL_CAP)
1770 cFYI(1, ("FCNTL cap"));
1771 if (cap & CIFS_UNIX_EXTATTR_CAP)
1772 cFYI(1, ("EXTATTR cap"));
1773 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1774 cFYI(1, ("POSIX path cap"));
1775 if (cap & CIFS_UNIX_XATTR_CAP)
1776 cFYI(1, ("XATTR cap"));
1777 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1778 cFYI(1, ("POSIX ACL cap"));
1779 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1780 cFYI(1, ("very large read cap"));
1781 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1782 cFYI(1, ("very large write cap"));
1783 #endif /* CIFS_DEBUG2 */
1784 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1785 if (vol_info == NULL) {
1786 cFYI(1, ("resetting capabilities failed"));
1788 cERROR(1, ("Negotiating Unix capabilities "
1789 "with the server failed. Consider "
1790 "mounting with the Unix Extensions\n"
1791 "disabled, if problems are found, "
1792 "by specifying the nounix mount "
1800 convert_delimiter(char *path, char delim)
1813 for (i = 0; path[i] != '\0'; i++) {
1814 if (path[i] == old_delim)
1820 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1821 char *mount_data, const char *devname)
1825 int address_type = AF_INET;
1826 struct socket *csocket = NULL;
1827 struct sockaddr_in sin_server;
1828 struct sockaddr_in6 sin_server6;
1829 struct smb_vol volume_info;
1830 struct cifsSesInfo *pSesInfo = NULL;
1831 struct cifsSesInfo *existingCifsSes = NULL;
1832 struct cifsTconInfo *tcon = NULL;
1833 struct TCP_Server_Info *srvTcp = NULL;
1837 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1839 memset(&volume_info, 0, sizeof(struct smb_vol));
1840 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1845 if (volume_info.nullauth) {
1846 cFYI(1, ("null user"));
1847 volume_info.username = "";
1848 } else if (volume_info.username) {
1849 /* BB fixme parse for domain name here */
1850 cFYI(1, ("Username: %s", volume_info.username));
1852 cifserror("No username specified");
1853 /* In userspace mount helper we can get user name from alternate
1854 locations such as env variables and files on disk */
1859 if (volume_info.UNCip && volume_info.UNC) {
1860 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1861 &sin_server.sin_addr.s_addr);
1864 /* not ipv4 address, try ipv6 */
1865 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1866 &sin_server6.sin6_addr.in6_u);
1868 address_type = AF_INET6;
1870 address_type = AF_INET;
1874 /* we failed translating address */
1879 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1882 } else if (volume_info.UNCip) {
1883 /* BB using ip addr as server name to connect to the
1885 cERROR(1, ("Connecting to DFS root not implemented yet"));
1888 } else /* which servers DFS root would we conect to */ {
1890 ("CIFS mount error: No UNC path (e.g. -o "
1891 "unc=//192.168.1.100/public) specified"));
1896 /* this is needed for ASCII cp to Unicode converts */
1897 if (volume_info.iocharset == NULL) {
1898 cifs_sb->local_nls = load_nls_default();
1899 /* load_nls_default can not return null */
1901 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1902 if (cifs_sb->local_nls == NULL) {
1903 cERROR(1, ("CIFS mount error: iocharset %s not found",
1904 volume_info.iocharset));
1910 if (address_type == AF_INET)
1911 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1912 NULL /* no ipv6 addr */,
1913 volume_info.username, &srvTcp);
1914 else if (address_type == AF_INET6) {
1915 cFYI(1, ("looking for ipv6 address"));
1916 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1917 &sin_server6.sin6_addr,
1918 volume_info.username, &srvTcp);
1925 cFYI(1, ("Existing tcp session with server found"));
1926 } else { /* create socket */
1927 if (volume_info.port)
1928 sin_server.sin_port = htons(volume_info.port);
1930 sin_server.sin_port = 0;
1931 if (address_type == AF_INET6) {
1932 cFYI(1, ("attempting ipv6 connect"));
1933 /* BB should we allow ipv6 on port 139? */
1934 /* other OS never observed in Wild doing 139 with v6 */
1935 rc = ipv6_connect(&sin_server6, &csocket);
1937 rc = ipv4_connect(&sin_server, &csocket,
1938 volume_info.source_rfc1001_name,
1939 volume_info.target_rfc1001_name);
1941 cERROR(1, ("Error connecting to IPv4 socket. "
1942 "Aborting operation"));
1943 if (csocket != NULL)
1944 sock_release(csocket);
1948 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1951 sock_release(csocket);
1954 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1955 sizeof(struct sockaddr_in));
1956 atomic_set(&srvTcp->inFlight, 0);
1957 /* BB Add code for ipv6 case too */
1958 srvTcp->ssocket = csocket;
1959 srvTcp->protocolType = IPV4;
1960 srvTcp->hostname = extract_hostname(volume_info.UNC);
1961 if (IS_ERR(srvTcp->hostname)) {
1962 rc = PTR_ERR(srvTcp->hostname);
1963 sock_release(csocket);
1966 init_waitqueue_head(&srvTcp->response_q);
1967 init_waitqueue_head(&srvTcp->request_q);
1968 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1969 /* at this point we are the only ones with the pointer
1970 to the struct since the kernel thread not created yet
1971 so no need to spinlock this init of tcpStatus */
1972 srvTcp->tcpStatus = CifsNew;
1973 init_MUTEX(&srvTcp->tcpSem);
1974 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1975 if (IS_ERR(srvTcp->tsk)) {
1976 rc = PTR_ERR(srvTcp->tsk);
1977 cERROR(1, ("error %d create cifsd thread", rc));
1979 sock_release(csocket);
1980 kfree(srvTcp->hostname);
1983 wait_for_completion(&cifsd_complete);
1985 memcpy(srvTcp->workstation_RFC1001_name,
1986 volume_info.source_rfc1001_name, 16);
1987 memcpy(srvTcp->server_RFC1001_name,
1988 volume_info.target_rfc1001_name, 16);
1989 srvTcp->sequence_number = 0;
1993 if (existingCifsSes) {
1994 pSesInfo = existingCifsSes;
1995 cFYI(1, ("Existing smb sess found (status=%d)",
1997 down(&pSesInfo->sesSem);
1998 if (pSesInfo->status == CifsNeedReconnect) {
1999 cFYI(1, ("Session needs reconnect"));
2000 rc = cifs_setup_session(xid, pSesInfo,
2001 cifs_sb->local_nls);
2003 up(&pSesInfo->sesSem);
2005 cFYI(1, ("Existing smb sess not found"));
2006 pSesInfo = sesInfoAlloc();
2007 if (pSesInfo == NULL)
2010 pSesInfo->server = srvTcp;
2011 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2012 NIPQUAD(sin_server.sin_addr.s_addr));
2016 /* volume_info.password freed at unmount */
2017 if (volume_info.password) {
2018 pSesInfo->password = volume_info.password;
2019 /* set to NULL to prevent freeing on exit */
2020 volume_info.password = NULL;
2022 if (volume_info.username)
2023 strncpy(pSesInfo->userName,
2024 volume_info.username,
2026 if (volume_info.domainname) {
2027 int len = strlen(volume_info.domainname);
2028 pSesInfo->domainName =
2029 kmalloc(len + 1, GFP_KERNEL);
2030 if (pSesInfo->domainName)
2031 strcpy(pSesInfo->domainName,
2032 volume_info.domainname);
2034 pSesInfo->linux_uid = volume_info.linux_uid;
2035 pSesInfo->overrideSecFlg = volume_info.secFlg;
2036 down(&pSesInfo->sesSem);
2037 /* BB FIXME need to pass vol->secFlgs BB */
2038 rc = cifs_setup_session(xid, pSesInfo,
2039 cifs_sb->local_nls);
2040 up(&pSesInfo->sesSem);
2042 atomic_inc(&srvTcp->socketUseCount);
2046 /* search for existing tcon to this server share */
2048 if (volume_info.rsize > CIFSMaxBufSize) {
2049 cERROR(1, ("rsize %d too large, using MaxBufSize",
2050 volume_info.rsize));
2051 cifs_sb->rsize = CIFSMaxBufSize;
2052 } else if ((volume_info.rsize) &&
2053 (volume_info.rsize <= CIFSMaxBufSize))
2054 cifs_sb->rsize = volume_info.rsize;
2056 cifs_sb->rsize = CIFSMaxBufSize;
2058 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2059 cERROR(1, ("wsize %d too large, using 4096 instead",
2060 volume_info.wsize));
2061 cifs_sb->wsize = 4096;
2062 } else if (volume_info.wsize)
2063 cifs_sb->wsize = volume_info.wsize;
2066 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2068 /* old default of CIFSMaxBufSize was too small now
2069 that SMB Write2 can send multiple pages in kvec.
2070 RFC1001 does not describe what happens when frame
2071 bigger than 128K is sent so use that as max in
2072 conjunction with 52K kvec constraint on arch with 4K
2075 if (cifs_sb->rsize < 2048) {
2076 cifs_sb->rsize = 2048;
2077 /* Windows ME may prefer this */
2078 cFYI(1, ("readsize set to minimum: 2048"));
2080 /* calculate prepath */
2081 cifs_sb->prepath = volume_info.prepath;
2082 if (cifs_sb->prepath) {
2083 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2084 /* we can not convert the / to \ in the path
2085 separators in the prefixpath yet because we do not
2086 know (until reset_cifs_unix_caps is called later)
2087 whether POSIX PATH CAP is available. We normalize
2088 the / to \ after reset_cifs_unix_caps is called */
2089 volume_info.prepath = NULL;
2091 cifs_sb->prepathlen = 0;
2092 cifs_sb->mnt_uid = volume_info.linux_uid;
2093 cifs_sb->mnt_gid = volume_info.linux_gid;
2094 cifs_sb->mnt_file_mode = volume_info.file_mode;
2095 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2096 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2097 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2099 if (volume_info.noperm)
2100 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2101 if (volume_info.setuids)
2102 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2103 if (volume_info.server_ino)
2104 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2105 if (volume_info.remap)
2106 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2107 if (volume_info.no_xattr)
2108 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2109 if (volume_info.sfu_emul)
2110 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2111 if (volume_info.nobrl)
2112 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2113 if (volume_info.cifs_acl)
2114 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2115 if (volume_info.override_uid)
2116 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2117 if (volume_info.override_gid)
2118 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2119 if (volume_info.direct_io) {
2120 cFYI(1, ("mounting share using direct i/o"));
2121 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2125 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2126 volume_info.username);
2128 cFYI(1, ("Found match on UNC path"));
2129 /* we can have only one retry value for a connection
2130 to a share so for resources mounted more than once
2131 to the same server share the last value passed in
2132 for the retry flag is used */
2133 tcon->retry = volume_info.retry;
2134 tcon->nocase = volume_info.nocase;
2136 tcon = tconInfoAlloc();
2140 /* check for null share name ie connecting to
2143 /* BB check if this works for exactly length
2145 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2146 && (strchr(volume_info.UNC + 3, '/') ==
2148 rc = connect_to_dfs_path(xid, pSesInfo,
2149 "", cifs_sb->local_nls,
2150 cifs_sb->mnt_cifs_flags &
2151 CIFS_MOUNT_MAP_SPECIAL_CHR);
2155 /* BB Do we need to wrap sesSem around
2156 * this TCon call and Unix SetFS as
2157 * we do on SessSetup and reconnect? */
2158 rc = CIFSTCon(xid, pSesInfo,
2160 tcon, cifs_sb->local_nls);
2161 cFYI(1, ("CIFS Tcon rc = %d", rc));
2164 atomic_inc(&pSesInfo->inUse);
2165 tcon->retry = volume_info.retry;
2166 tcon->nocase = volume_info.nocase;
2172 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2173 sb->s_maxbytes = (u64) 1 << 63;
2175 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2178 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2179 sb->s_time_gran = 100;
2181 /* on error free sesinfo and tcon struct if needed */
2183 /* if session setup failed, use count is zero but
2184 we still need to free cifsd thread */
2185 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2186 spin_lock(&GlobalMid_Lock);
2187 srvTcp->tcpStatus = CifsExiting;
2188 spin_unlock(&GlobalMid_Lock);
2190 struct task_struct *tsk;
2191 /* If we could verify that kthread_stop would
2192 always wake up processes blocked in
2193 tcp in recv_mesg then we could remove the
2195 force_sig(SIGKILL, srvTcp->tsk);
2201 /* If find_unc succeeded then rc == 0 so we can not end */
2202 if (tcon) /* up accidently freeing someone elses tcon struct */
2204 if (existingCifsSes == NULL) {
2206 if ((pSesInfo->server) &&
2207 (pSesInfo->status == CifsGood)) {
2209 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2210 /* if the socketUseCount is now zero */
2211 if ((temp_rc == -ESHUTDOWN) &&
2212 (pSesInfo->server) &&
2213 (pSesInfo->server->tsk)) {
2214 struct task_struct *tsk;
2216 pSesInfo->server->tsk);
2217 tsk = pSesInfo->server->tsk;
2222 cFYI(1, ("No session or bad tcon"));
2223 if ((pSesInfo->server) &&
2224 (pSesInfo->server->tsk)) {
2225 struct task_struct *tsk;
2227 pSesInfo->server->tsk);
2228 tsk = pSesInfo->server->tsk;
2233 sesInfoFree(pSesInfo);
2234 /* pSesInfo = NULL; */
2238 atomic_inc(&tcon->useCount);
2239 cifs_sb->tcon = tcon;
2240 tcon->ses = pSesInfo;
2242 /* do not care if following two calls succeed - informational */
2244 CIFSSMBQFSDeviceInfo(xid, tcon);
2245 CIFSSMBQFSAttributeInfo(xid, tcon);
2248 /* tell server which Unix caps we support */
2249 if (tcon->ses->capabilities & CAP_UNIX)
2250 /* reset of caps checks mount to see if unix extensions
2251 disabled for just this mount */
2252 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2254 tcon->unix_ext = 0; /* server does not support them */
2256 /* convert forward to back slashes in prepath here if needed */
2257 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2258 convert_delimiter(cifs_sb->prepath,
2259 CIFS_DIR_SEP(cifs_sb));
2261 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2262 cifs_sb->rsize = 1024 * 127;
2264 ("no very large read support, rsize now 127K"));
2266 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2267 cifs_sb->wsize = min(cifs_sb->wsize,
2268 (tcon->ses->server->maxBuf -
2269 MAX_CIFS_HDR_SIZE));
2270 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2271 cifs_sb->rsize = min(cifs_sb->rsize,
2272 (tcon->ses->server->maxBuf -
2273 MAX_CIFS_HDR_SIZE));
2276 /* volume_info.password is freed above when existing session found
2277 (in which case it is not needed anymore) but when new sesion is created
2278 the password ptr is put in the new session structure (in which case the
2279 password will be freed at unmount time) */
2281 /* zero out password before freeing */
2282 if (volume_info.password != NULL) {
2283 memset(volume_info.password, 0, strlen(volume_info.password));
2284 kfree(volume_info.password);
2286 kfree(volume_info.UNC);
2287 kfree(volume_info.prepath);
2293 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2294 char session_key[CIFS_SESS_KEY_SIZE],
2295 const struct nls_table *nls_codepage)
2297 struct smb_hdr *smb_buffer;
2298 struct smb_hdr *smb_buffer_response;
2299 SESSION_SETUP_ANDX *pSMB;
2300 SESSION_SETUP_ANDX *pSMBr;
2305 int remaining_words = 0;
2306 int bytes_returned = 0;
2311 cFYI(1, ("In sesssetup"));
2314 user = ses->userName;
2315 domain = ses->domainName;
2316 smb_buffer = cifs_buf_get();
2317 if (smb_buffer == NULL) {
2320 smb_buffer_response = smb_buffer;
2321 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2323 /* send SMBsessionSetup here */
2324 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2325 NULL /* no tCon exists yet */ , 13 /* wct */ );
2327 smb_buffer->Mid = GetNextMid(ses->server);
2328 pSMB->req_no_secext.AndXCommand = 0xFF;
2329 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2330 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2332 if (ses->server->secMode &
2333 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2334 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2336 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2337 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2338 if (ses->capabilities & CAP_UNICODE) {
2339 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2340 capabilities |= CAP_UNICODE;
2342 if (ses->capabilities & CAP_STATUS32) {
2343 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2344 capabilities |= CAP_STATUS32;
2346 if (ses->capabilities & CAP_DFS) {
2347 smb_buffer->Flags2 |= SMBFLG2_DFS;
2348 capabilities |= CAP_DFS;
2350 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2352 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2353 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2355 pSMB->req_no_secext.CaseSensitivePasswordLength =
2356 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2357 bcc_ptr = pByteArea(smb_buffer);
2358 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2359 bcc_ptr += CIFS_SESS_KEY_SIZE;
2360 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2361 bcc_ptr += CIFS_SESS_KEY_SIZE;
2363 if (ses->capabilities & CAP_UNICODE) {
2364 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2369 bytes_returned = 0; /* skip null user */
2372 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2374 /* convert number of 16 bit words to bytes */
2375 bcc_ptr += 2 * bytes_returned;
2376 bcc_ptr += 2; /* trailing null */
2379 cifs_strtoUCS((__le16 *) bcc_ptr,
2380 "CIFS_LINUX_DOM", 32, nls_codepage);
2383 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2385 bcc_ptr += 2 * bytes_returned;
2388 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2390 bcc_ptr += 2 * bytes_returned;
2392 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2394 bcc_ptr += 2 * bytes_returned;
2397 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2399 bcc_ptr += 2 * bytes_returned;
2403 strncpy(bcc_ptr, user, 200);
2404 bcc_ptr += strnlen(user, 200);
2408 if (domain == NULL) {
2409 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2410 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2412 strncpy(bcc_ptr, domain, 64);
2413 bcc_ptr += strnlen(domain, 64);
2417 strcpy(bcc_ptr, "Linux version ");
2418 bcc_ptr += strlen("Linux version ");
2419 strcpy(bcc_ptr, utsname()->release);
2420 bcc_ptr += strlen(utsname()->release) + 1;
2421 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2422 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2424 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2425 smb_buffer->smb_buf_length += count;
2426 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2428 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2429 &bytes_returned, CIFS_LONG_OP);
2431 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2432 } else if ((smb_buffer_response->WordCount == 3)
2433 || (smb_buffer_response->WordCount == 4)) {
2434 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2435 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2436 if (action & GUEST_LOGIN)
2437 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2438 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2440 cFYI(1, ("UID = %d ", ses->Suid));
2441 /* response can have either 3 or 4 word count - Samba sends 3 */
2442 bcc_ptr = pByteArea(smb_buffer_response);
2443 if ((pSMBr->resp.hdr.WordCount == 3)
2444 || ((pSMBr->resp.hdr.WordCount == 4)
2445 && (blob_len < pSMBr->resp.ByteCount))) {
2446 if (pSMBr->resp.hdr.WordCount == 4)
2447 bcc_ptr += blob_len;
2449 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2450 if ((long) (bcc_ptr) % 2) {
2452 (BCC(smb_buffer_response) - 1) / 2;
2453 /* Unicode strings must be word
2458 BCC(smb_buffer_response) / 2;
2461 UniStrnlen((wchar_t *) bcc_ptr,
2462 remaining_words - 1);
2463 /* We look for obvious messed up bcc or strings in response so we do not go off
2464 the end since (at least) WIN2K and Windows XP have a major bug in not null
2465 terminating last Unicode string in response */
2467 kfree(ses->serverOS);
2468 ses->serverOS = kzalloc(2 * (len + 1),
2470 if (ses->serverOS == NULL)
2471 goto sesssetup_nomem;
2472 cifs_strfromUCS_le(ses->serverOS,
2475 bcc_ptr += 2 * (len + 1);
2476 remaining_words -= len + 1;
2477 ses->serverOS[2 * len] = 0;
2478 ses->serverOS[1 + (2 * len)] = 0;
2479 if (remaining_words > 0) {
2480 len = UniStrnlen((wchar_t *)bcc_ptr,
2482 kfree(ses->serverNOS);
2483 ses->serverNOS = kzalloc(2 * (len + 1),
2485 if (ses->serverNOS == NULL)
2486 goto sesssetup_nomem;
2487 cifs_strfromUCS_le(ses->serverNOS,
2490 bcc_ptr += 2 * (len + 1);
2491 ses->serverNOS[2 * len] = 0;
2492 ses->serverNOS[1 + (2 * len)] = 0;
2493 if (strncmp(ses->serverNOS,
2494 "NT LAN Manager 4", 16) == 0) {
2495 cFYI(1, ("NT4 server"));
2496 ses->flags |= CIFS_SES_NT4;
2498 remaining_words -= len + 1;
2499 if (remaining_words > 0) {
2500 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2501 /* last string is not always null terminated
2502 (for e.g. for Windows XP & 2000) */
2503 if (ses->serverDomain)
2504 kfree(ses->serverDomain);
2508 if (ses->serverDomain == NULL)
2509 goto sesssetup_nomem;
2510 cifs_strfromUCS_le(ses->serverDomain,
2513 bcc_ptr += 2 * (len + 1);
2514 ses->serverDomain[2*len] = 0;
2515 ses->serverDomain[1+(2*len)] = 0;
2516 } else { /* else no more room so create
2517 dummy domain string */
2518 if (ses->serverDomain)
2519 kfree(ses->serverDomain);
2521 kzalloc(2, GFP_KERNEL);
2523 } else { /* no room so create dummy domain
2526 /* if these kcallocs fail not much we
2527 can do, but better to not fail the
2529 kfree(ses->serverDomain);
2531 kzalloc(2, GFP_KERNEL);
2532 kfree(ses->serverNOS);
2534 kzalloc(2, GFP_KERNEL);
2536 } else { /* ASCII */
2537 len = strnlen(bcc_ptr, 1024);
2538 if (((long) bcc_ptr + len) - (long)
2539 pByteArea(smb_buffer_response)
2540 <= BCC(smb_buffer_response)) {
2541 kfree(ses->serverOS);
2542 ses->serverOS = kzalloc(len + 1,
2544 if (ses->serverOS == NULL)
2545 goto sesssetup_nomem;
2546 strncpy(ses->serverOS, bcc_ptr, len);
2549 /* null terminate the string */
2553 len = strnlen(bcc_ptr, 1024);
2554 kfree(ses->serverNOS);
2555 ses->serverNOS = kzalloc(len + 1,
2557 if (ses->serverNOS == NULL)
2558 goto sesssetup_nomem;
2559 strncpy(ses->serverNOS, bcc_ptr, len);
2564 len = strnlen(bcc_ptr, 1024);
2565 if (ses->serverDomain)
2566 kfree(ses->serverDomain);
2567 ses->serverDomain = kzalloc(len + 1,
2569 if (ses->serverDomain == NULL)
2570 goto sesssetup_nomem;
2571 strncpy(ses->serverDomain, bcc_ptr,
2578 ("Variable field of length %d "
2579 "extends beyond end of smb ",
2584 (" Security Blob Length extends beyond "
2589 (" Invalid Word count %d: ",
2590 smb_buffer_response->WordCount));
2593 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2594 since that could make reconnection harder, and
2595 reconnection might be needed to free memory */
2596 cifs_buf_release(smb_buffer);
2602 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2603 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2604 const struct nls_table *nls_codepage)
2606 struct smb_hdr *smb_buffer;
2607 struct smb_hdr *smb_buffer_response;
2608 SESSION_SETUP_ANDX *pSMB;
2609 SESSION_SETUP_ANDX *pSMBr;
2613 int remaining_words = 0;
2614 int bytes_returned = 0;
2616 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2617 PNEGOTIATE_MESSAGE SecurityBlob;
2618 PCHALLENGE_MESSAGE SecurityBlob2;
2619 __u32 negotiate_flags, capabilities;
2622 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2625 domain = ses->domainName;
2626 *pNTLMv2_flag = false;
2627 smb_buffer = cifs_buf_get();
2628 if (smb_buffer == NULL) {
2631 smb_buffer_response = smb_buffer;
2632 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2633 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2635 /* send SMBsessionSetup here */
2636 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2637 NULL /* no tCon exists yet */ , 12 /* wct */ );
2639 smb_buffer->Mid = GetNextMid(ses->server);
2640 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2641 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2643 pSMB->req.AndXCommand = 0xFF;
2644 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2645 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2647 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2648 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2650 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2651 CAP_EXTENDED_SECURITY;
2652 if (ses->capabilities & CAP_UNICODE) {
2653 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2654 capabilities |= CAP_UNICODE;
2656 if (ses->capabilities & CAP_STATUS32) {
2657 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2658 capabilities |= CAP_STATUS32;
2660 if (ses->capabilities & CAP_DFS) {
2661 smb_buffer->Flags2 |= SMBFLG2_DFS;
2662 capabilities |= CAP_DFS;
2664 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2666 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2667 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2668 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2669 SecurityBlob->MessageType = NtLmNegotiate;
2671 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2672 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2673 NTLMSSP_NEGOTIATE_56 |
2674 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2676 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2677 /* if (ntlmv2_support)
2678 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2679 /* setup pointers to domain name and workstation name */
2680 bcc_ptr += SecurityBlobLength;
2682 SecurityBlob->WorkstationName.Buffer = 0;
2683 SecurityBlob->WorkstationName.Length = 0;
2684 SecurityBlob->WorkstationName.MaximumLength = 0;
2686 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2687 along with username on auth request (ie the response to challenge) */
2688 SecurityBlob->DomainName.Buffer = 0;
2689 SecurityBlob->DomainName.Length = 0;
2690 SecurityBlob->DomainName.MaximumLength = 0;
2691 if (ses->capabilities & CAP_UNICODE) {
2692 if ((long) bcc_ptr % 2) {
2698 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2700 bcc_ptr += 2 * bytes_returned;
2702 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2704 bcc_ptr += 2 * bytes_returned;
2705 bcc_ptr += 2; /* null terminate Linux version */
2707 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2709 bcc_ptr += 2 * bytes_returned;
2712 bcc_ptr += 2; /* null terminate network opsys string */
2715 bcc_ptr += 2; /* null domain */
2716 } else { /* ASCII */
2717 strcpy(bcc_ptr, "Linux version ");
2718 bcc_ptr += strlen("Linux version ");
2719 strcpy(bcc_ptr, utsname()->release);
2720 bcc_ptr += strlen(utsname()->release) + 1;
2721 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2722 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2723 bcc_ptr++; /* empty domain field */
2726 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2727 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2728 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2729 smb_buffer->smb_buf_length += count;
2730 pSMB->req.ByteCount = cpu_to_le16(count);
2732 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2733 &bytes_returned, CIFS_LONG_OP);
2735 if (smb_buffer_response->Status.CifsError ==
2736 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2740 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2741 } else if ((smb_buffer_response->WordCount == 3)
2742 || (smb_buffer_response->WordCount == 4)) {
2743 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2744 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2746 if (action & GUEST_LOGIN)
2747 cFYI(1, (" Guest login"));
2748 /* Do we want to set anything in SesInfo struct when guest login? */
2750 bcc_ptr = pByteArea(smb_buffer_response);
2751 /* response can have either 3 or 4 word count - Samba sends 3 */
2753 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2754 if (SecurityBlob2->MessageType != NtLmChallenge) {
2756 ("Unexpected NTLMSSP message type received %d",
2757 SecurityBlob2->MessageType));
2759 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2760 cFYI(1, ("UID = %d", ses->Suid));
2761 if ((pSMBr->resp.hdr.WordCount == 3)
2762 || ((pSMBr->resp.hdr.WordCount == 4)
2764 pSMBr->resp.ByteCount))) {
2766 if (pSMBr->resp.hdr.WordCount == 4) {
2767 bcc_ptr += blob_len;
2768 cFYI(1, ("Security Blob Length %d",
2772 cFYI(1, ("NTLMSSP Challenge rcvd"));
2774 memcpy(ses->server->cryptKey,
2775 SecurityBlob2->Challenge,
2776 CIFS_CRYPTO_KEY_SIZE);
2777 if (SecurityBlob2->NegotiateFlags &
2778 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2779 *pNTLMv2_flag = true;
2781 if ((SecurityBlob2->NegotiateFlags &
2782 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2783 || (sign_CIFS_PDUs > 1))
2784 ses->server->secMode |=
2785 SECMODE_SIGN_REQUIRED;
2786 if ((SecurityBlob2->NegotiateFlags &
2787 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2788 ses->server->secMode |=
2789 SECMODE_SIGN_ENABLED;
2791 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2792 if ((long) (bcc_ptr) % 2) {
2794 (BCC(smb_buffer_response)
2796 /* Must word align unicode strings */
2801 (smb_buffer_response) / 2;
2804 UniStrnlen((wchar_t *) bcc_ptr,
2805 remaining_words - 1);
2806 /* We look for obvious messed up bcc or strings in response so we do not go off
2807 the end since (at least) WIN2K and Windows XP have a major bug in not null
2808 terminating last Unicode string in response */
2810 kfree(ses->serverOS);
2812 kzalloc(2 * (len + 1), GFP_KERNEL);
2813 cifs_strfromUCS_le(ses->serverOS,
2817 bcc_ptr += 2 * (len + 1);
2818 remaining_words -= len + 1;
2819 ses->serverOS[2 * len] = 0;
2820 ses->serverOS[1 + (2 * len)] = 0;
2821 if (remaining_words > 0) {
2822 len = UniStrnlen((wchar_t *)
2826 kfree(ses->serverNOS);
2828 kzalloc(2 * (len + 1),
2830 cifs_strfromUCS_le(ses->
2836 bcc_ptr += 2 * (len + 1);
2837 ses->serverNOS[2 * len] = 0;
2840 remaining_words -= len + 1;
2841 if (remaining_words > 0) {
2842 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2843 /* last string not always null terminated
2844 (for e.g. for Windows XP & 2000) */
2845 kfree(ses->serverDomain);
2857 ses->serverDomain[2*len]
2862 } /* else no more room so create dummy domain string */
2864 kfree(ses->serverDomain);
2869 } else { /* no room so create dummy domain and NOS string */
2870 kfree(ses->serverDomain);
2872 kzalloc(2, GFP_KERNEL);
2873 kfree(ses->serverNOS);
2875 kzalloc(2, GFP_KERNEL);
2877 } else { /* ASCII */
2878 len = strnlen(bcc_ptr, 1024);
2879 if (((long) bcc_ptr + len) - (long)
2880 pByteArea(smb_buffer_response)
2881 <= BCC(smb_buffer_response)) {
2883 kfree(ses->serverOS);
2887 strncpy(ses->serverOS,
2891 bcc_ptr[0] = 0; /* null terminate string */
2894 len = strnlen(bcc_ptr, 1024);
2895 kfree(ses->serverNOS);
2899 strncpy(ses->serverNOS, bcc_ptr, len);
2904 len = strnlen(bcc_ptr, 1024);
2905 kfree(ses->serverDomain);
2909 strncpy(ses->serverDomain,
2916 ("field of length %d "
2917 "extends beyond end of smb",
2921 cERROR(1, ("Security Blob Length extends beyond"
2925 cERROR(1, ("No session structure passed in."));
2929 (" Invalid Word count %d:",
2930 smb_buffer_response->WordCount));
2934 cifs_buf_release(smb_buffer);
2939 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2940 char *ntlm_session_key, bool ntlmv2_flag,
2941 const struct nls_table *nls_codepage)
2943 struct smb_hdr *smb_buffer;
2944 struct smb_hdr *smb_buffer_response;
2945 SESSION_SETUP_ANDX *pSMB;
2946 SESSION_SETUP_ANDX *pSMBr;
2951 int remaining_words = 0;
2952 int bytes_returned = 0;
2954 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2955 PAUTHENTICATE_MESSAGE SecurityBlob;
2956 __u32 negotiate_flags, capabilities;
2959 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2962 user = ses->userName;
2963 domain = ses->domainName;
2964 smb_buffer = cifs_buf_get();
2965 if (smb_buffer == NULL) {
2968 smb_buffer_response = smb_buffer;
2969 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2970 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2972 /* send SMBsessionSetup here */
2973 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2974 NULL /* no tCon exists yet */ , 12 /* wct */ );
2976 smb_buffer->Mid = GetNextMid(ses->server);
2977 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2978 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2979 pSMB->req.AndXCommand = 0xFF;
2980 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2981 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2983 pSMB->req.hdr.Uid = ses->Suid;
2985 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2986 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2988 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2989 CAP_EXTENDED_SECURITY;
2990 if (ses->capabilities & CAP_UNICODE) {
2991 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2992 capabilities |= CAP_UNICODE;
2994 if (ses->capabilities & CAP_STATUS32) {
2995 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2996 capabilities |= CAP_STATUS32;
2998 if (ses->capabilities & CAP_DFS) {
2999 smb_buffer->Flags2 |= SMBFLG2_DFS;
3000 capabilities |= CAP_DFS;
3002 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3004 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3005 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3006 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3007 SecurityBlob->MessageType = NtLmAuthenticate;
3008 bcc_ptr += SecurityBlobLength;
3009 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3010 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3011 0x80000000 | NTLMSSP_NEGOTIATE_128;
3013 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3015 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3017 /* setup pointers to domain name and workstation name */
3019 SecurityBlob->WorkstationName.Buffer = 0;
3020 SecurityBlob->WorkstationName.Length = 0;
3021 SecurityBlob->WorkstationName.MaximumLength = 0;
3022 SecurityBlob->SessionKey.Length = 0;
3023 SecurityBlob->SessionKey.MaximumLength = 0;
3024 SecurityBlob->SessionKey.Buffer = 0;
3026 SecurityBlob->LmChallengeResponse.Length = 0;
3027 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3028 SecurityBlob->LmChallengeResponse.Buffer = 0;
3030 SecurityBlob->NtChallengeResponse.Length =
3031 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3032 SecurityBlob->NtChallengeResponse.MaximumLength =
3033 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3034 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3035 SecurityBlob->NtChallengeResponse.Buffer =
3036 cpu_to_le32(SecurityBlobLength);
3037 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3038 bcc_ptr += CIFS_SESS_KEY_SIZE;
3040 if (ses->capabilities & CAP_UNICODE) {
3041 if (domain == NULL) {
3042 SecurityBlob->DomainName.Buffer = 0;
3043 SecurityBlob->DomainName.Length = 0;
3044 SecurityBlob->DomainName.MaximumLength = 0;
3046 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3049 SecurityBlob->DomainName.MaximumLength =
3051 SecurityBlob->DomainName.Buffer =
3052 cpu_to_le32(SecurityBlobLength);
3054 SecurityBlobLength += ln;
3055 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3058 SecurityBlob->UserName.Buffer = 0;
3059 SecurityBlob->UserName.Length = 0;
3060 SecurityBlob->UserName.MaximumLength = 0;
3062 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3065 SecurityBlob->UserName.MaximumLength =
3067 SecurityBlob->UserName.Buffer =
3068 cpu_to_le32(SecurityBlobLength);
3070 SecurityBlobLength += ln;
3071 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3074 /* SecurityBlob->WorkstationName.Length =
3075 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3076 SecurityBlob->WorkstationName.Length *= 2;
3077 SecurityBlob->WorkstationName.MaximumLength =
3078 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3079 SecurityBlob->WorkstationName.Buffer =
3080 cpu_to_le32(SecurityBlobLength);
3081 bcc_ptr += SecurityBlob->WorkstationName.Length;
3082 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3083 SecurityBlob->WorkstationName.Length =
3084 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3086 if ((long) bcc_ptr % 2) {
3091 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3093 bcc_ptr += 2 * bytes_returned;
3095 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3097 bcc_ptr += 2 * bytes_returned;
3098 bcc_ptr += 2; /* null term version string */
3100 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3102 bcc_ptr += 2 * bytes_returned;
3105 bcc_ptr += 2; /* null terminate network opsys string */
3108 bcc_ptr += 2; /* null domain */
3109 } else { /* ASCII */
3110 if (domain == NULL) {
3111 SecurityBlob->DomainName.Buffer = 0;
3112 SecurityBlob->DomainName.Length = 0;
3113 SecurityBlob->DomainName.MaximumLength = 0;
3116 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3117 strncpy(bcc_ptr, domain, 63);
3118 ln = strnlen(domain, 64);
3119 SecurityBlob->DomainName.MaximumLength =
3121 SecurityBlob->DomainName.Buffer =
3122 cpu_to_le32(SecurityBlobLength);
3124 SecurityBlobLength += ln;
3125 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3128 SecurityBlob->UserName.Buffer = 0;
3129 SecurityBlob->UserName.Length = 0;
3130 SecurityBlob->UserName.MaximumLength = 0;
3133 strncpy(bcc_ptr, user, 63);
3134 ln = strnlen(user, 64);
3135 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3136 SecurityBlob->UserName.Buffer =
3137 cpu_to_le32(SecurityBlobLength);
3139 SecurityBlobLength += ln;
3140 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3142 /* BB fill in our workstation name if known BB */
3144 strcpy(bcc_ptr, "Linux version ");
3145 bcc_ptr += strlen("Linux version ");
3146 strcpy(bcc_ptr, utsname()->release);
3147 bcc_ptr += strlen(utsname()->release) + 1;
3148 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3149 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3150 bcc_ptr++; /* null domain */
3153 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3154 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3155 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3156 smb_buffer->smb_buf_length += count;
3157 pSMB->req.ByteCount = cpu_to_le16(count);
3159 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3160 &bytes_returned, CIFS_LONG_OP);
3162 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3163 } else if ((smb_buffer_response->WordCount == 3) ||
3164 (smb_buffer_response->WordCount == 4)) {
3165 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3166 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3167 if (action & GUEST_LOGIN)
3168 cFYI(1, (" Guest login")); /* BB Should we set anything
3169 in SesInfo struct ? */
3170 /* if (SecurityBlob2->MessageType != NtLm??) {
3171 cFYI("Unexpected message type on auth response is %d"));
3176 ("Check challenge UID %d vs auth response UID %d",
3177 ses->Suid, smb_buffer_response->Uid));
3178 /* UID left in wire format */
3179 ses->Suid = smb_buffer_response->Uid;
3180 bcc_ptr = pByteArea(smb_buffer_response);
3181 /* response can have either 3 or 4 word count - Samba sends 3 */
3182 if ((pSMBr->resp.hdr.WordCount == 3)
3183 || ((pSMBr->resp.hdr.WordCount == 4)
3185 pSMBr->resp.ByteCount))) {
3186 if (pSMBr->resp.hdr.WordCount == 4) {
3190 ("Security Blob Length %d ",
3195 ("NTLMSSP response to Authenticate "));
3197 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3198 if ((long) (bcc_ptr) % 2) {
3200 (BCC(smb_buffer_response)
3202 bcc_ptr++; /* Unicode strings must be word aligned */
3204 remaining_words = BCC(smb_buffer_response) / 2;
3206 len = UniStrnlen((wchar_t *) bcc_ptr,
3207 remaining_words - 1);
3208 /* We look for obvious messed up bcc or strings in response so we do not go off
3209 the end since (at least) WIN2K and Windows XP have a major bug in not null
3210 terminating last Unicode string in response */
3212 kfree(ses->serverOS);
3214 kzalloc(2 * (len + 1), GFP_KERNEL);
3215 cifs_strfromUCS_le(ses->serverOS,
3219 bcc_ptr += 2 * (len + 1);
3220 remaining_words -= len + 1;
3221 ses->serverOS[2 * len] = 0;
3222 ses->serverOS[1 + (2 * len)] = 0;
3223 if (remaining_words > 0) {
3224 len = UniStrnlen((wchar_t *)
3228 kfree(ses->serverNOS);
3230 kzalloc(2 * (len + 1),
3232 cifs_strfromUCS_le(ses->
3238 bcc_ptr += 2 * (len + 1);
3239 ses->serverNOS[2 * len] = 0;
3240 ses->serverNOS[1+(2*len)] = 0;
3241 remaining_words -= len + 1;
3242 if (remaining_words > 0) {
3243 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3244 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3245 if (ses->serverDomain)
3246 kfree(ses->serverDomain);
3271 } /* else no more room so create dummy domain string */
3273 if (ses->serverDomain)
3274 kfree(ses->serverDomain);
3275 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3277 } else { /* no room so create dummy domain and NOS string */
3278 if (ses->serverDomain)
3279 kfree(ses->serverDomain);
3280 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3281 kfree(ses->serverNOS);
3282 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3284 } else { /* ASCII */
3285 len = strnlen(bcc_ptr, 1024);
3286 if (((long) bcc_ptr + len) -
3287 (long) pByteArea(smb_buffer_response)
3288 <= BCC(smb_buffer_response)) {
3290 kfree(ses->serverOS);
3291 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3292 strncpy(ses->serverOS,bcc_ptr, len);
3295 bcc_ptr[0] = 0; /* null terminate the string */
3298 len = strnlen(bcc_ptr, 1024);
3299 kfree(ses->serverNOS);
3300 ses->serverNOS = kzalloc(len+1,
3302 strncpy(ses->serverNOS,
3308 len = strnlen(bcc_ptr, 1024);
3309 if (ses->serverDomain)
3310 kfree(ses->serverDomain);
3314 strncpy(ses->serverDomain,
3320 cFYI(1, ("field of length %d "
3321 "extends beyond end of smb ",
3325 cERROR(1, ("Security Blob extends beyond end "
3329 cERROR(1, ("No session structure passed in."));
3332 cERROR(1, ("Invalid Word count %d: ",
3333 smb_buffer_response->WordCount));
3337 cifs_buf_release(smb_buffer);
3343 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3344 const char *tree, struct cifsTconInfo *tcon,
3345 const struct nls_table *nls_codepage)
3347 struct smb_hdr *smb_buffer;
3348 struct smb_hdr *smb_buffer_response;
3351 unsigned char *bcc_ptr;
3359 smb_buffer = cifs_buf_get();
3360 if (smb_buffer == NULL) {
3363 smb_buffer_response = smb_buffer;
3365 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3366 NULL /*no tid */ , 4 /*wct */ );
3368 smb_buffer->Mid = GetNextMid(ses->server);
3369 smb_buffer->Uid = ses->Suid;
3370 pSMB = (TCONX_REQ *) smb_buffer;
3371 pSMBr = (TCONX_RSP *) smb_buffer_response;
3373 pSMB->AndXCommand = 0xFF;
3374 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3375 bcc_ptr = &pSMB->Password[0];
3376 if ((ses->server->secMode) & SECMODE_USER) {
3377 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3378 *bcc_ptr = 0; /* password is null byte */
3379 bcc_ptr++; /* skip password */
3380 /* already aligned so no need to do it below */
3382 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3383 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3384 specified as required (when that support is added to
3385 the vfs in the future) as only NTLM or the much
3386 weaker LANMAN (which we do not send by default) is accepted
3387 by Samba (not sure whether other servers allow
3388 NTLMv2 password here) */
3389 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3390 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3391 (ses->server->secType == LANMAN))
3392 calc_lanman_hash(ses, bcc_ptr);
3394 #endif /* CIFS_WEAK_PW_HASH */
3395 SMBNTencrypt(ses->password,
3396 ses->server->cryptKey,
3399 bcc_ptr += CIFS_SESS_KEY_SIZE;
3400 if (ses->capabilities & CAP_UNICODE) {
3401 /* must align unicode strings */
3402 *bcc_ptr = 0; /* null byte password */
3407 if (ses->server->secMode &
3408 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3409 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3411 if (ses->capabilities & CAP_STATUS32) {
3412 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3414 if (ses->capabilities & CAP_DFS) {
3415 smb_buffer->Flags2 |= SMBFLG2_DFS;
3417 if (ses->capabilities & CAP_UNICODE) {
3418 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3420 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3421 6 /* max utf8 char length in bytes */ *
3422 (/* server len*/ + 256 /* share len */), nls_codepage);
3423 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3424 bcc_ptr += 2; /* skip trailing null */
3425 } else { /* ASCII */
3426 strcpy(bcc_ptr, tree);
3427 bcc_ptr += strlen(tree) + 1;
3429 strcpy(bcc_ptr, "?????");
3430 bcc_ptr += strlen("?????");
3432 count = bcc_ptr - &pSMB->Password[0];
3433 pSMB->hdr.smb_buf_length += count;
3434 pSMB->ByteCount = cpu_to_le16(count);
3436 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3439 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3440 /* above now done in SendReceive */
3441 if ((rc == 0) && (tcon != NULL)) {
3442 tcon->tidStatus = CifsGood;
3443 tcon->tid = smb_buffer_response->Tid;
3444 bcc_ptr = pByteArea(smb_buffer_response);
3445 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3446 /* skip service field (NB: this field is always ASCII) */
3448 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3449 (bcc_ptr[2] == 'C')) {
3450 cFYI(1, ("IPC connection"));
3453 } else if (length == 2) {
3454 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3455 /* the most common case */
3456 cFYI(1, ("disk share connection"));
3459 bcc_ptr += length + 1;
3460 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3461 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3462 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3463 if ((bcc_ptr + (2 * length)) -
3464 pByteArea(smb_buffer_response) <=
3465 BCC(smb_buffer_response)) {
3466 kfree(tcon->nativeFileSystem);
3467 tcon->nativeFileSystem =
3468 kzalloc(length + 2, GFP_KERNEL);
3469 if (tcon->nativeFileSystem)
3471 tcon->nativeFileSystem,
3473 length, nls_codepage);
3474 bcc_ptr += 2 * length;
3475 bcc_ptr[0] = 0; /* null terminate the string */
3479 /* else do not bother copying these information fields*/
3481 length = strnlen(bcc_ptr, 1024);
3482 if ((bcc_ptr + length) -
3483 pByteArea(smb_buffer_response) <=
3484 BCC(smb_buffer_response)) {
3485 kfree(tcon->nativeFileSystem);
3486 tcon->nativeFileSystem =
3487 kzalloc(length + 1, GFP_KERNEL);
3488 if (tcon->nativeFileSystem)
3489 strncpy(tcon->nativeFileSystem, bcc_ptr,
3492 /* else do not bother copying these information fields*/
3494 if ((smb_buffer_response->WordCount == 3) ||
3495 (smb_buffer_response->WordCount == 7))
3496 /* field is in same location */
3497 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3500 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3501 } else if ((rc == 0) && tcon == NULL) {
3502 /* all we need to save for IPC$ connection */
3503 ses->ipc_tid = smb_buffer_response->Tid;
3506 cifs_buf_release(smb_buffer);
3511 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3515 struct cifsSesInfo *ses = NULL;
3516 struct task_struct *cifsd_task;
3521 if (cifs_sb->tcon) {
3522 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3523 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3528 DeleteTconOplockQEntries(cifs_sb->tcon);
3529 tconInfoFree(cifs_sb->tcon);
3530 if ((ses) && (ses->server)) {
3531 /* save off task so we do not refer to ses later */
3532 cifsd_task = ses->server->tsk;
3533 cFYI(1, ("About to do SMBLogoff "));
3534 rc = CIFSSMBLogoff(xid, ses);
3538 } else if (rc == -ESHUTDOWN) {
3539 cFYI(1, ("Waking up socket by sending signal"));
3541 force_sig(SIGKILL, cifsd_task);
3542 kthread_stop(cifsd_task);
3545 } /* else - we have an smb session
3546 left on this socket do not kill cifsd */
3548 cFYI(1, ("No session or bad tcon"));
3551 cifs_sb->tcon = NULL;
3552 tmp = cifs_sb->prepath;
3553 cifs_sb->prepathlen = 0;
3554 cifs_sb->prepath = NULL;
3557 schedule_timeout_interruptible(msecs_to_jiffies(500));
3565 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3566 struct nls_table *nls_info)
3569 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3570 bool ntlmv2_flag = false;
3573 /* what if server changes its buffer size after dropping the session? */
3574 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3575 rc = CIFSSMBNegotiate(xid, pSesInfo);
3576 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3577 rc = CIFSSMBNegotiate(xid, pSesInfo);
3582 spin_lock(&GlobalMid_Lock);
3583 if (pSesInfo->server->tcpStatus != CifsExiting)
3584 pSesInfo->server->tcpStatus = CifsGood;
3587 spin_unlock(&GlobalMid_Lock);
3593 pSesInfo->flags = 0;
3594 pSesInfo->capabilities = pSesInfo->server->capabilities;
3595 if (linuxExtEnabled == 0)
3596 pSesInfo->capabilities &= (~CAP_UNIX);
3597 /* pSesInfo->sequence_number = 0;*/
3599 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3600 pSesInfo->server->secMode,
3601 pSesInfo->server->capabilities,
3602 pSesInfo->server->timeAdj));
3603 if (experimEnabled < 2)
3604 rc = CIFS_SessSetup(xid, pSesInfo,
3605 first_time, nls_info);
3606 else if (extended_security
3607 && (pSesInfo->capabilities
3608 & CAP_EXTENDED_SECURITY)
3609 && (pSesInfo->server->secType == NTLMSSP)) {
3611 } else if (extended_security
3612 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3613 && (pSesInfo->server->secType == RawNTLMSSP)) {
3614 cFYI(1, ("NTLMSSP sesssetup"));
3615 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3622 cFYI(1, ("more secure NTLM ver2 hash"));
3623 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3628 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3630 CalcNTLMv2_response(pSesInfo,
3633 cifs_calculate_ntlmv2_mac_key(
3634 pSesInfo->server->mac_signing_key,
3635 response, ntlm_session_key,*/
3637 /* BB Put dummy sig in SessSetup PDU? */
3644 SMBNTencrypt(pSesInfo->password,
3645 pSesInfo->server->cryptKey,
3649 cifs_calculate_mac_key(
3650 &pSesInfo->server->mac_signing_key,
3652 pSesInfo->password);
3654 /* for better security the weaker lanman hash not sent
3655 in AuthSessSetup so we no longer calculate it */
3657 rc = CIFSNTLMSSPAuthSessSetup(xid,
3663 } else { /* old style NTLM 0.12 session setup */
3664 SMBNTencrypt(pSesInfo->password,
3665 pSesInfo->server->cryptKey,
3669 cifs_calculate_mac_key(
3670 &pSesInfo->server->mac_signing_key,
3671 ntlm_session_key, pSesInfo->password);
3673 rc = CIFSSessSetup(xid, pSesInfo,
3674 ntlm_session_key, nls_info);
3677 cERROR(1, ("Send error in SessSetup = %d", rc));
3679 cFYI(1, ("CIFS Session Established successfully"));
3680 pSesInfo->status = CifsGood;