4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 extern mempool_t *cifs_req_poolp;
63 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
64 char *iocharset; /* local code page for mapping to and from Unicode */
65 char source_rfc1001_name[16]; /* netbios name of client */
66 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
80 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
83 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool remap:1; /* set to remap seven reserved chars in filenames */
86 bool posix_paths:1; /* unset to not ask for posix pathnames. */
89 bool nullauth:1; /* attempt to authenticate with null user */
90 unsigned nocase; /* request case insensitive filenames */
91 unsigned nobrl; /* disable sending byte range locks to srv */
95 unsigned short int port;
99 static int ipv4_connect(struct sockaddr_in *psin_server,
100 struct socket **csocket,
102 char *server_netb_name);
103 static int ipv6_connect(struct sockaddr_in6 *psin_server,
104 struct socket **csocket);
108 * cifs tcp session reconnection
110 * mark tcp session as reconnecting so temporarily locked
111 * mark all smb sessions as reconnecting for tcp session
112 * reconnect tcp session
113 * wake up waiters on reconnection? - (not needed currently)
117 cifs_reconnect(struct TCP_Server_Info *server)
120 struct list_head *tmp;
121 struct cifsSesInfo *ses;
122 struct cifsTconInfo *tcon;
123 struct mid_q_entry *mid_entry;
125 spin_lock(&GlobalMid_Lock);
126 if (kthread_should_stop()) {
127 /* the demux thread will exit normally
128 next time through the loop */
129 spin_unlock(&GlobalMid_Lock);
132 server->tcpStatus = CifsNeedReconnect;
133 spin_unlock(&GlobalMid_Lock);
136 cFYI(1, ("Reconnecting tcp session"));
138 /* before reconnecting the tcp session, mark the smb session (uid)
139 and the tid bad so they are not used until reconnected */
140 read_lock(&GlobalSMBSeslock);
141 list_for_each(tmp, &GlobalSMBSessionList) {
142 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
144 if (ses->server == server) {
145 ses->status = CifsNeedReconnect;
149 /* else tcp and smb sessions need reconnection */
151 list_for_each(tmp, &GlobalTreeConnectionList) {
152 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
153 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
154 tcon->tidStatus = CifsNeedReconnect;
156 read_unlock(&GlobalSMBSeslock);
157 /* do not want to be sending data on a socket we are freeing */
158 down(&server->tcpSem);
159 if (server->ssocket) {
160 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
161 server->ssocket->flags));
162 kernel_sock_shutdown(server->ssocket, SHUT_WR);
163 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
164 server->ssocket->state,
165 server->ssocket->flags));
166 sock_release(server->ssocket);
167 server->ssocket = NULL;
170 spin_lock(&GlobalMid_Lock);
171 list_for_each(tmp, &server->pending_mid_q) {
172 mid_entry = list_entry(tmp, struct
176 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
177 /* Mark other intransit requests as needing
178 retry so we do not immediately mark the
179 session bad again (ie after we reconnect
180 below) as they timeout too */
181 mid_entry->midState = MID_RETRY_NEEDED;
185 spin_unlock(&GlobalMid_Lock);
188 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
190 if (server->protocolType == IPV6) {
191 rc = ipv6_connect(&server->addr.sockAddr6,
194 rc = ipv4_connect(&server->addr.sockAddr,
196 server->workstation_RFC1001_name,
197 server->server_RFC1001_name);
200 cFYI(1, ("reconnect error %d", rc));
203 atomic_inc(&tcpSesReconnectCount);
204 spin_lock(&GlobalMid_Lock);
205 if (!kthread_should_stop())
206 server->tcpStatus = CifsGood;
207 server->sequence_number = 0;
208 spin_unlock(&GlobalMid_Lock);
209 /* atomic_set(&server->inFlight,0);*/
210 wake_up(&server->response_q);
218 0 not a transact2, or all data present
219 >0 transact2 with that much data missing
220 -EINVAL = invalid transact2
223 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
225 struct smb_t2_rsp *pSMBt;
227 int data_in_this_rsp;
230 if (pSMB->Command != SMB_COM_TRANSACTION2)
233 /* check for plausible wct, bcc and t2 data and parm sizes */
234 /* check for parm and data offset going beyond end of smb */
235 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
236 cFYI(1, ("invalid transact2 word count"));
240 pSMBt = (struct smb_t2_rsp *)pSMB;
242 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
243 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
245 remaining = total_data_size - data_in_this_rsp;
249 else if (remaining < 0) {
250 cFYI(1, ("total data %d smaller than data in frame %d",
251 total_data_size, data_in_this_rsp));
254 cFYI(1, ("missing %d bytes from transact2, check next response",
256 if (total_data_size > maxBufSize) {
257 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
258 total_data_size, maxBufSize));
265 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
267 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
268 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
273 char *data_area_of_target;
274 char *data_area_of_buf2;
277 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
279 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
280 cFYI(1, ("total data size of primary and secondary t2 differ"));
283 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
285 remaining = total_data_size - total_in_buf;
290 if (remaining == 0) /* nothing to do, ignore */
293 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
294 if (remaining < total_in_buf2) {
295 cFYI(1, ("transact2 2nd response contains too much data"));
298 /* find end of first SMB data area */
299 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
300 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
301 /* validate target area */
303 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
304 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
306 data_area_of_target += total_in_buf;
308 /* copy second buffer into end of first buffer */
309 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
310 total_in_buf += total_in_buf2;
311 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
312 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
313 byte_count += total_in_buf2;
314 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
316 byte_count = pTargetSMB->smb_buf_length;
317 byte_count += total_in_buf2;
319 /* BB also add check that we are not beyond maximum buffer size */
321 pTargetSMB->smb_buf_length = byte_count;
323 if (remaining == total_in_buf2) {
324 cFYI(1, ("found the last secondary response"));
325 return 0; /* we are done */
326 } else /* more responses to go */
332 cifs_demultiplex_thread(struct TCP_Server_Info *server)
335 unsigned int pdu_length, total_read;
336 struct smb_hdr *smb_buffer = NULL;
337 struct smb_hdr *bigbuf = NULL;
338 struct smb_hdr *smallbuf = NULL;
339 struct msghdr smb_msg;
341 struct socket *csocket = server->ssocket;
342 struct list_head *tmp;
343 struct cifsSesInfo *ses;
344 struct task_struct *task_to_wake = NULL;
345 struct mid_q_entry *mid_entry;
347 bool isLargeBuf = false;
351 current->flags |= PF_MEMALLOC;
352 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
353 write_lock(&GlobalSMBSeslock);
354 atomic_inc(&tcpSesAllocCount);
355 length = tcpSesAllocCount.counter;
356 write_unlock(&GlobalSMBSeslock);
358 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
362 while (!kthread_should_stop()) {
365 if (bigbuf == NULL) {
366 bigbuf = cifs_buf_get();
368 cERROR(1, ("No memory for large SMB response"));
370 /* retry will check if exiting */
373 } else if (isLargeBuf) {
374 /* we are reusing a dirty large buf, clear its start */
375 memset(bigbuf, 0, sizeof(struct smb_hdr));
378 if (smallbuf == NULL) {
379 smallbuf = cifs_small_buf_get();
381 cERROR(1, ("No memory for SMB response"));
383 /* retry will check if exiting */
386 /* beginning of smb buffer is cleared in our buf_get */
387 } else /* if existing small buf clear beginning */
388 memset(smallbuf, 0, sizeof(struct smb_hdr));
392 smb_buffer = smallbuf;
393 iov.iov_base = smb_buffer;
395 smb_msg.msg_control = NULL;
396 smb_msg.msg_controllen = 0;
397 pdu_length = 4; /* enough to get RFC1001 header */
400 kernel_recvmsg(csocket, &smb_msg,
401 &iov, 1, pdu_length, 0 /* BB other flags? */);
403 if (kthread_should_stop()) {
405 } else if (server->tcpStatus == CifsNeedReconnect) {
406 cFYI(1, ("Reconnect after server stopped responding"));
407 cifs_reconnect(server);
408 cFYI(1, ("call to reconnect done"));
409 csocket = server->ssocket;
411 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
412 msleep(1); /* minimum sleep to prevent looping
413 allowing socket to clear and app threads to set
414 tcpStatus CifsNeedReconnect if server hung */
419 } else if (length <= 0) {
420 if (server->tcpStatus == CifsNew) {
421 cFYI(1, ("tcp session abend after SMBnegprot"));
422 /* some servers kill the TCP session rather than
423 returning an SMB negprot error, in which
424 case reconnecting here is not going to help,
425 and so simply return error to mount */
428 if (!try_to_freeze() && (length == -EINTR)) {
429 cFYI(1, ("cifsd thread killed"));
432 cFYI(1, ("Reconnect after unexpected peek error %d",
434 cifs_reconnect(server);
435 csocket = server->ssocket;
436 wake_up(&server->response_q);
438 } else if (length < pdu_length) {
439 cFYI(1, ("requested %d bytes but only got %d bytes",
440 pdu_length, length));
441 pdu_length -= length;
446 /* The right amount was read from socket - 4 bytes */
447 /* so we can now interpret the length field */
449 /* the first byte big endian of the length field,
450 is actually not part of the length but the type
451 with the most common, zero, as regular data */
452 temp = *((char *) smb_buffer);
454 /* Note that FC 1001 length is big endian on the wire,
455 but we convert it here so it is always manipulated
456 as host byte order */
457 pdu_length = ntohl(smb_buffer->smb_buf_length);
458 smb_buffer->smb_buf_length = pdu_length;
460 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
462 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
464 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
465 cFYI(1, ("Good RFC 1002 session rsp"));
467 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
468 /* we get this from Windows 98 instead of
469 an error on SMB negprot response */
470 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
472 if (server->tcpStatus == CifsNew) {
473 /* if nack on negprot (rather than
474 ret of smb negprot error) reconnecting
475 not going to help, ret error to mount */
478 /* give server a second to
479 clean up before reconnect attempt */
481 /* always try 445 first on reconnect
482 since we get NACK on some if we ever
483 connected to port 139 (the NACK is
484 since we do not begin with RFC1001
485 session initialize frame) */
486 server->addr.sockAddr.sin_port =
488 cifs_reconnect(server);
489 csocket = server->ssocket;
490 wake_up(&server->response_q);
493 } else if (temp != (char) 0) {
494 cERROR(1, ("Unknown RFC 1002 frame"));
495 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
497 cifs_reconnect(server);
498 csocket = server->ssocket;
502 /* else we have an SMB response */
503 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
504 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
505 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
506 length, pdu_length+4));
507 cifs_reconnect(server);
508 csocket = server->ssocket;
509 wake_up(&server->response_q);
516 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
518 memcpy(bigbuf, smallbuf, 4);
522 iov.iov_base = 4 + (char *)smb_buffer;
523 iov.iov_len = pdu_length;
524 for (total_read = 0; total_read < pdu_length;
525 total_read += length) {
526 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
527 pdu_length - total_read, 0);
528 if (kthread_should_stop() ||
529 (length == -EINTR)) {
533 } else if (server->tcpStatus == CifsNeedReconnect) {
534 cifs_reconnect(server);
535 csocket = server->ssocket;
536 /* Reconnect wakes up rspns q */
537 /* Now we will reread sock */
540 } else if ((length == -ERESTARTSYS) ||
541 (length == -EAGAIN)) {
542 msleep(1); /* minimum sleep to prevent looping,
543 allowing socket to clear and app
544 threads to set tcpStatus
545 CifsNeedReconnect if server hung*/
548 } else if (length <= 0) {
549 cERROR(1, ("Received no data, expecting %d",
550 pdu_length - total_read));
551 cifs_reconnect(server);
552 csocket = server->ssocket;
559 else if (reconnect == 1)
562 length += 4; /* account for rfc1002 hdr */
565 dump_smb(smb_buffer, length);
566 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
567 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
573 spin_lock(&GlobalMid_Lock);
574 list_for_each(tmp, &server->pending_mid_q) {
575 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
577 if ((mid_entry->mid == smb_buffer->Mid) &&
578 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
579 (mid_entry->command == smb_buffer->Command)) {
580 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
581 /* We have a multipart transact2 resp */
583 if (mid_entry->resp_buf) {
584 /* merge response - fix up 1st*/
585 if (coalesce_t2(smb_buffer,
586 mid_entry->resp_buf)) {
587 mid_entry->multiRsp =
591 /* all parts received */
592 mid_entry->multiEnd =
598 cERROR(1,("1st trans2 resp needs bigbuf"));
599 /* BB maybe we can fix this up, switch
600 to already allocated large buffer? */
602 /* Have first buffer */
603 mid_entry->resp_buf =
605 mid_entry->largeBuf =
612 mid_entry->resp_buf = smb_buffer;
613 mid_entry->largeBuf = isLargeBuf;
615 task_to_wake = mid_entry->tsk;
616 mid_entry->midState = MID_RESPONSE_RECEIVED;
617 #ifdef CONFIG_CIFS_STATS2
618 mid_entry->when_received = jiffies;
620 /* so we do not time out requests to server
621 which is still responding (since server could
622 be busy but not dead) */
623 server->lstrp = jiffies;
627 spin_unlock(&GlobalMid_Lock);
629 /* Was previous buf put in mpx struct for multi-rsp? */
631 /* smb buffer will be freed by user thread */
637 wake_up_process(task_to_wake);
638 } else if (!is_valid_oplock_break(smb_buffer, server) &&
640 cERROR(1, ("No task to wake, unknown frame received! "
641 "NumMids %d", midCount.counter));
642 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
643 sizeof(struct smb_hdr));
644 #ifdef CONFIG_CIFS_DEBUG2
645 cifs_dump_detail(smb_buffer);
646 cifs_dump_mids(server);
647 #endif /* CIFS_DEBUG2 */
650 } /* end while !EXITING */
652 spin_lock(&GlobalMid_Lock);
653 server->tcpStatus = CifsExiting;
654 spin_unlock(&GlobalMid_Lock);
656 /* don't exit until kthread_stop is called */
657 set_current_state(TASK_UNINTERRUPTIBLE);
658 while (!kthread_should_stop()) {
660 set_current_state(TASK_UNINTERRUPTIBLE);
662 set_current_state(TASK_RUNNING);
664 /* check if we have blocked requests that need to free */
665 /* Note that cifs_max_pending is normally 50, but
666 can be set at module install time to as little as two */
667 spin_lock(&GlobalMid_Lock);
668 if (atomic_read(&server->inFlight) >= cifs_max_pending)
669 atomic_set(&server->inFlight, cifs_max_pending - 1);
670 /* We do not want to set the max_pending too low or we
671 could end up with the counter going negative */
672 spin_unlock(&GlobalMid_Lock);
673 /* Although there should not be any requests blocked on
674 this queue it can not hurt to be paranoid and try to wake up requests
675 that may haven been blocked when more than 50 at time were on the wire
676 to the same server - they now will see the session is in exit state
677 and get out of SendReceive. */
678 wake_up_all(&server->request_q);
679 /* give those requests time to exit */
682 if (server->ssocket) {
683 sock_release(csocket);
684 server->ssocket = NULL;
686 /* buffer usuallly freed in free_mid - need to free it here on exit */
687 cifs_buf_release(bigbuf);
688 if (smallbuf) /* no sense logging a debug message if NULL */
689 cifs_small_buf_release(smallbuf);
691 read_lock(&GlobalSMBSeslock);
692 if (list_empty(&server->pending_mid_q)) {
693 /* loop through server session structures attached to this and
695 list_for_each(tmp, &GlobalSMBSessionList) {
697 list_entry(tmp, struct cifsSesInfo,
699 if (ses->server == server) {
700 ses->status = CifsExiting;
704 read_unlock(&GlobalSMBSeslock);
706 /* although we can not zero the server struct pointer yet,
707 since there are active requests which may depnd on them,
708 mark the corresponding SMB sessions as exiting too */
709 list_for_each(tmp, &GlobalSMBSessionList) {
710 ses = list_entry(tmp, struct cifsSesInfo,
712 if (ses->server == server)
713 ses->status = CifsExiting;
716 spin_lock(&GlobalMid_Lock);
717 list_for_each(tmp, &server->pending_mid_q) {
718 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
719 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
720 cFYI(1, ("Clearing Mid 0x%x - waking up ",
722 task_to_wake = mid_entry->tsk;
724 wake_up_process(task_to_wake);
727 spin_unlock(&GlobalMid_Lock);
728 read_unlock(&GlobalSMBSeslock);
729 /* 1/8th of sec is more than enough time for them to exit */
733 if (!list_empty(&server->pending_mid_q)) {
734 /* mpx threads have not exited yet give them
735 at least the smb send timeout time for long ops */
736 /* due to delays on oplock break requests, we need
737 to wait at least 45 seconds before giving up
738 on a request getting a response and going ahead
740 cFYI(1, ("Wait for exit from demultiplex thread"));
742 /* if threads still have not exited they are probably never
743 coming home not much else we can do but free the memory */
746 write_lock(&GlobalSMBSeslock);
747 atomic_dec(&tcpSesAllocCount);
748 length = tcpSesAllocCount.counter;
750 /* last chance to mark ses pointers invalid
751 if there are any pointing to this (e.g
752 if a crazy root user tried to kill cifsd
753 kernel thread explicitly this might happen) */
754 list_for_each(tmp, &GlobalSMBSessionList) {
755 ses = list_entry(tmp, struct cifsSesInfo,
757 if (ses->server == server)
760 write_unlock(&GlobalSMBSeslock);
762 kfree(server->hostname);
765 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
771 /* extract the host portion of the UNC string */
773 extract_hostname(const char *unc)
779 /* skip double chars at beginning of string */
780 /* BB: check validity of these bytes? */
783 /* delimiter between hostname and sharename is always '\\' now */
784 delim = strchr(src, '\\');
786 return ERR_PTR(-EINVAL);
789 dst = kmalloc((len + 1), GFP_KERNEL);
791 return ERR_PTR(-ENOMEM);
793 memcpy(dst, src, len);
800 cifs_parse_mount_options(char *options, const char *devname,
805 unsigned int temp_len, i, j;
811 if (Local_System_Name[0] != 0)
812 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
814 char *nodename = utsname()->nodename;
815 int n = strnlen(nodename, 15);
816 memset(vol->source_rfc1001_name, 0x20, 15);
817 for (i = 0; i < n; i++) {
818 /* does not have to be perfect mapping since field is
819 informational, only used for servers that do not support
820 port 445 and it can be overridden at mount time */
821 vol->source_rfc1001_name[i] = toupper(nodename[i]);
824 vol->source_rfc1001_name[15] = 0;
825 /* null target name indicates to use *SMBSERVR default called name
826 if we end up sending RFC1001 session initialize */
827 vol->target_rfc1001_name[0] = 0;
828 vol->linux_uid = current->uid; /* current->euid instead? */
829 vol->linux_gid = current->gid;
830 vol->dir_mode = S_IRWXUGO;
831 /* 2767 perms indicate mandatory locking support */
832 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
834 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
836 /* default is always to request posix paths. */
837 vol->posix_paths = 1;
842 if (strncmp(options, "sep=", 4) == 0) {
843 if (options[4] != 0) {
844 separator[0] = options[4];
847 cFYI(1, ("Null separator not allowed"));
851 while ((data = strsep(&options, separator)) != NULL) {
854 if ((value = strchr(data, '=')) != NULL)
857 /* Have to parse this before we parse for "user" */
858 if (strnicmp(data, "user_xattr", 10) == 0) {
860 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
862 } else if (strnicmp(data, "user", 4) == 0) {
865 "CIFS: invalid or missing username\n");
866 return 1; /* needs_arg; */
867 } else if (!*value) {
868 /* null user, ie anonymous, authentication */
871 if (strnlen(value, 200) < 200) {
872 vol->username = value;
874 printk(KERN_WARNING "CIFS: username too long\n");
877 } else if (strnicmp(data, "pass", 4) == 0) {
879 vol->password = NULL;
881 } else if (value[0] == 0) {
882 /* check if string begins with double comma
883 since that would mean the password really
884 does start with a comma, and would not
885 indicate an empty string */
886 if (value[1] != separator[0]) {
887 vol->password = NULL;
891 temp_len = strlen(value);
892 /* removed password length check, NTLM passwords
893 can be arbitrarily long */
895 /* if comma in password, the string will be
896 prematurely null terminated. Commas in password are
897 specified across the cifs mount interface by a double
898 comma ie ,, and a comma used as in other cases ie ','
899 as a parameter delimiter/separator is single and due
900 to the strsep above is temporarily zeroed. */
902 /* NB: password legally can have multiple commas and
903 the only illegal character in a password is null */
905 if ((value[temp_len] == 0) &&
906 (value[temp_len+1] == separator[0])) {
908 value[temp_len] = separator[0];
909 temp_len += 2; /* move after second comma */
910 while (value[temp_len] != 0) {
911 if (value[temp_len] == separator[0]) {
912 if (value[temp_len+1] ==
914 /* skip second comma */
917 /* single comma indicating start
924 if (value[temp_len] == 0) {
928 /* point option to start of next parm */
929 options = value + temp_len + 1;
931 /* go from value to value + temp_len condensing
932 double commas to singles. Note that this ends up
933 allocating a few bytes too many, which is ok */
934 vol->password = kzalloc(temp_len, GFP_KERNEL);
935 if (vol->password == NULL) {
936 printk(KERN_WARNING "CIFS: no memory "
940 for (i = 0, j = 0; i < temp_len; i++, j++) {
941 vol->password[j] = value[i];
942 if (value[i] == separator[0]
943 && value[i+1] == separator[0]) {
944 /* skip second comma */
948 vol->password[j] = 0;
950 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
951 if (vol->password == NULL) {
952 printk(KERN_WARNING "CIFS: no memory "
956 strcpy(vol->password, value);
958 } else if (strnicmp(data, "ip", 2) == 0) {
959 if (!value || !*value) {
961 } else if (strnlen(value, 35) < 35) {
964 printk(KERN_WARNING "CIFS: ip address "
968 } else if (strnicmp(data, "sec", 3) == 0) {
969 if (!value || !*value) {
970 cERROR(1, ("no security value specified"));
972 } else if (strnicmp(value, "krb5i", 5) == 0) {
973 vol->secFlg |= CIFSSEC_MAY_KRB5 |
975 } else if (strnicmp(value, "krb5p", 5) == 0) {
976 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
978 cERROR(1, ("Krb5 cifs privacy not supported"));
980 } else if (strnicmp(value, "krb5", 4) == 0) {
981 vol->secFlg |= CIFSSEC_MAY_KRB5;
982 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
983 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
985 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
986 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
987 } else if (strnicmp(value, "ntlmi", 5) == 0) {
988 vol->secFlg |= CIFSSEC_MAY_NTLM |
990 } else if (strnicmp(value, "ntlm", 4) == 0) {
991 /* ntlm is default so can be turned off too */
992 vol->secFlg |= CIFSSEC_MAY_NTLM;
993 } else if (strnicmp(value, "nontlm", 6) == 0) {
994 /* BB is there a better way to do this? */
995 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
996 #ifdef CONFIG_CIFS_WEAK_PW_HASH
997 } else if (strnicmp(value, "lanman", 6) == 0) {
998 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1000 } else if (strnicmp(value, "none", 4) == 0) {
1003 cERROR(1, ("bad security option: %s", value));
1006 } else if ((strnicmp(data, "unc", 3) == 0)
1007 || (strnicmp(data, "target", 6) == 0)
1008 || (strnicmp(data, "path", 4) == 0)) {
1009 if (!value || !*value) {
1010 printk(KERN_WARNING "CIFS: invalid path to "
1011 "network resource\n");
1012 return 1; /* needs_arg; */
1014 if ((temp_len = strnlen(value, 300)) < 300) {
1015 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1016 if (vol->UNC == NULL)
1018 strcpy(vol->UNC, value);
1019 if (strncmp(vol->UNC, "//", 2) == 0) {
1022 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1024 "CIFS: UNC Path does not begin "
1025 "with // or \\\\ \n");
1029 printk(KERN_WARNING "CIFS: UNC name too long\n");
1032 } else if ((strnicmp(data, "domain", 3) == 0)
1033 || (strnicmp(data, "workgroup", 5) == 0)) {
1034 if (!value || !*value) {
1035 printk(KERN_WARNING "CIFS: invalid domain name\n");
1036 return 1; /* needs_arg; */
1038 /* BB are there cases in which a comma can be valid in
1039 a domain name and need special handling? */
1040 if (strnlen(value, 256) < 256) {
1041 vol->domainname = value;
1042 cFYI(1, ("Domain name set"));
1044 printk(KERN_WARNING "CIFS: domain name too "
1048 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1049 if (!value || !*value) {
1051 "CIFS: invalid path prefix\n");
1052 return 1; /* needs_argument */
1054 if ((temp_len = strnlen(value, 1024)) < 1024) {
1055 if (value[0] != '/')
1056 temp_len++; /* missing leading slash */
1057 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1058 if (vol->prepath == NULL)
1060 if (value[0] != '/') {
1061 vol->prepath[0] = '/';
1062 strcpy(vol->prepath+1, value);
1064 strcpy(vol->prepath, value);
1065 cFYI(1, ("prefix path %s", vol->prepath));
1067 printk(KERN_WARNING "CIFS: prefix too long\n");
1070 } else if (strnicmp(data, "iocharset", 9) == 0) {
1071 if (!value || !*value) {
1072 printk(KERN_WARNING "CIFS: invalid iocharset "
1074 return 1; /* needs_arg; */
1076 if (strnlen(value, 65) < 65) {
1077 if (strnicmp(value, "default", 7))
1078 vol->iocharset = value;
1079 /* if iocharset not set then load_nls_default
1080 is used by caller */
1081 cFYI(1, ("iocharset set to %s", value));
1083 printk(KERN_WARNING "CIFS: iocharset name "
1087 } else if (strnicmp(data, "uid", 3) == 0) {
1088 if (value && *value) {
1090 simple_strtoul(value, &value, 0);
1091 vol->override_uid = 1;
1093 } else if (strnicmp(data, "gid", 3) == 0) {
1094 if (value && *value) {
1096 simple_strtoul(value, &value, 0);
1097 vol->override_gid = 1;
1099 } else if (strnicmp(data, "file_mode", 4) == 0) {
1100 if (value && *value) {
1102 simple_strtoul(value, &value, 0);
1104 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1105 if (value && *value) {
1107 simple_strtoul(value, &value, 0);
1109 } else if (strnicmp(data, "dirmode", 4) == 0) {
1110 if (value && *value) {
1112 simple_strtoul(value, &value, 0);
1114 } else if (strnicmp(data, "port", 4) == 0) {
1115 if (value && *value) {
1117 simple_strtoul(value, &value, 0);
1119 } else if (strnicmp(data, "rsize", 5) == 0) {
1120 if (value && *value) {
1122 simple_strtoul(value, &value, 0);
1124 } else if (strnicmp(data, "wsize", 5) == 0) {
1125 if (value && *value) {
1127 simple_strtoul(value, &value, 0);
1129 } else if (strnicmp(data, "sockopt", 5) == 0) {
1130 if (value && *value) {
1132 simple_strtoul(value, &value, 0);
1134 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1135 if (!value || !*value || (*value == ' ')) {
1136 cFYI(1, ("invalid (empty) netbiosname"));
1138 memset(vol->source_rfc1001_name, 0x20, 15);
1139 for (i = 0; i < 15; i++) {
1140 /* BB are there cases in which a comma can be
1141 valid in this workstation netbios name (and need
1142 special handling)? */
1144 /* We do not uppercase netbiosname for user */
1148 vol->source_rfc1001_name[i] =
1151 /* The string has 16th byte zero still from
1152 set at top of the function */
1153 if ((i == 15) && (value[i] != 0))
1154 printk(KERN_WARNING "CIFS: netbiosname"
1155 " longer than 15 truncated.\n");
1157 } else if (strnicmp(data, "servern", 7) == 0) {
1158 /* servernetbiosname specified override *SMBSERVER */
1159 if (!value || !*value || (*value == ' ')) {
1160 cFYI(1, ("empty server netbiosname specified"));
1162 /* last byte, type, is 0x20 for servr type */
1163 memset(vol->target_rfc1001_name, 0x20, 16);
1165 for (i = 0; i < 15; i++) {
1166 /* BB are there cases in which a comma can be
1167 valid in this workstation netbios name
1168 (and need special handling)? */
1170 /* user or mount helper must uppercase
1175 vol->target_rfc1001_name[i] =
1178 /* The string has 16th byte zero still from
1179 set at top of the function */
1180 if ((i == 15) && (value[i] != 0))
1181 printk(KERN_WARNING "CIFS: server net"
1182 "biosname longer than 15 truncated.\n");
1184 } else if (strnicmp(data, "credentials", 4) == 0) {
1186 } else if (strnicmp(data, "version", 3) == 0) {
1188 } else if (strnicmp(data, "guest", 5) == 0) {
1190 } else if (strnicmp(data, "rw", 2) == 0) {
1192 } else if ((strnicmp(data, "suid", 4) == 0) ||
1193 (strnicmp(data, "nosuid", 6) == 0) ||
1194 (strnicmp(data, "exec", 4) == 0) ||
1195 (strnicmp(data, "noexec", 6) == 0) ||
1196 (strnicmp(data, "nodev", 5) == 0) ||
1197 (strnicmp(data, "noauto", 6) == 0) ||
1198 (strnicmp(data, "dev", 3) == 0)) {
1199 /* The mount tool or mount.cifs helper (if present)
1200 uses these opts to set flags, and the flags are read
1201 by the kernel vfs layer before we get here (ie
1202 before read super) so there is no point trying to
1203 parse these options again and set anything and it
1204 is ok to just ignore them */
1206 } else if (strnicmp(data, "ro", 2) == 0) {
1208 } else if (strnicmp(data, "hard", 4) == 0) {
1210 } else if (strnicmp(data, "soft", 4) == 0) {
1212 } else if (strnicmp(data, "perm", 4) == 0) {
1214 } else if (strnicmp(data, "noperm", 6) == 0) {
1216 } else if (strnicmp(data, "mapchars", 8) == 0) {
1218 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1220 } else if (strnicmp(data, "sfu", 3) == 0) {
1222 } else if (strnicmp(data, "nosfu", 5) == 0) {
1224 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1225 vol->posix_paths = 1;
1226 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1227 vol->posix_paths = 0;
1228 } else if (strnicmp(data, "nounix", 6) == 0) {
1229 vol->no_linux_ext = 1;
1230 } else if (strnicmp(data, "nolinux", 7) == 0) {
1231 vol->no_linux_ext = 1;
1232 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1233 (strnicmp(data, "ignorecase", 10) == 0)) {
1235 } else if (strnicmp(data, "brl", 3) == 0) {
1237 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1238 (strnicmp(data, "nolock", 6) == 0)) {
1240 /* turn off mandatory locking in mode
1241 if remote locking is turned off since the
1242 local vfs will do advisory */
1243 if (vol->file_mode ==
1244 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1245 vol->file_mode = S_IALLUGO;
1246 } else if (strnicmp(data, "setuids", 7) == 0) {
1248 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1250 } else if (strnicmp(data, "dynperm", 7) == 0) {
1251 vol->dynperm = true;
1252 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1253 vol->dynperm = false;
1254 } else if (strnicmp(data, "nohard", 6) == 0) {
1256 } else if (strnicmp(data, "nosoft", 6) == 0) {
1258 } else if (strnicmp(data, "nointr", 6) == 0) {
1260 } else if (strnicmp(data, "intr", 4) == 0) {
1262 } else if (strnicmp(data, "serverino", 7) == 0) {
1263 vol->server_ino = 1;
1264 } else if (strnicmp(data, "noserverino", 9) == 0) {
1265 vol->server_ino = 0;
1266 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1268 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1270 } else if (strnicmp(data, "acl", 3) == 0) {
1271 vol->no_psx_acl = 0;
1272 } else if (strnicmp(data, "noacl", 5) == 0) {
1273 vol->no_psx_acl = 1;
1274 } else if (strnicmp(data, "sign", 4) == 0) {
1275 vol->secFlg |= CIFSSEC_MUST_SIGN;
1276 /* } else if (strnicmp(data, "seal",4) == 0) {
1277 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1278 } else if (strnicmp(data, "direct", 6) == 0) {
1280 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1282 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1283 if (!value || !*value) {
1284 vol->in6_addr = NULL;
1285 } else if (strnlen(value, 49) == 48) {
1286 vol->in6_addr = value;
1288 printk(KERN_WARNING "CIFS: ip v6 address not "
1289 "48 characters long\n");
1292 } else if (strnicmp(data, "noac", 4) == 0) {
1293 printk(KERN_WARNING "CIFS: Mount option noac not "
1294 "supported. Instead set "
1295 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1297 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1300 if (vol->UNC == NULL) {
1301 if (devname == NULL) {
1302 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1306 if ((temp_len = strnlen(devname, 300)) < 300) {
1307 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1308 if (vol->UNC == NULL)
1310 strcpy(vol->UNC, devname);
1311 if (strncmp(vol->UNC, "//", 2) == 0) {
1314 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1315 printk(KERN_WARNING "CIFS: UNC Path does not "
1316 "begin with // or \\\\ \n");
1319 value = strpbrk(vol->UNC+2, "/\\");
1323 printk(KERN_WARNING "CIFS: UNC name too long\n");
1327 if (vol->UNCip == NULL)
1328 vol->UNCip = &vol->UNC[2];
1333 static struct cifsSesInfo *
1334 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1335 struct in6_addr *target_ip6_addr,
1336 char *userName, struct TCP_Server_Info **psrvTcp)
1338 struct list_head *tmp;
1339 struct cifsSesInfo *ses;
1343 read_lock(&GlobalSMBSeslock);
1344 list_for_each(tmp, &GlobalSMBSessionList) {
1345 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1349 if (target_ip_addr &&
1350 ses->server->addr.sockAddr.sin_addr.s_addr != target_ip_addr->s_addr)
1352 else if (target_ip6_addr &&
1353 memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1354 target_ip6_addr, sizeof(*target_ip6_addr)))
1356 /* BB lock server and tcp session; increment use count here?? */
1358 /* found a match on the TCP session */
1359 *psrvTcp = ses->server;
1361 /* BB check if reconnection needed */
1362 if (strncmp(ses->userName, userName, MAX_USERNAME_SIZE) == 0) {
1363 read_unlock(&GlobalSMBSeslock);
1364 /* Found exact match on both TCP and
1368 /* else tcp and smb sessions need reconnection */
1370 read_unlock(&GlobalSMBSeslock);
1375 static struct cifsTconInfo *
1376 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1378 struct list_head *tmp;
1379 struct cifsTconInfo *tcon;
1382 read_lock(&GlobalSMBSeslock);
1384 list_for_each(tmp, &GlobalTreeConnectionList) {
1385 cFYI(1, ("Next tcon"));
1386 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1387 if (!tcon->ses || !tcon->ses->server)
1390 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1391 cFYI(1, ("old ip addr: %x == new ip %x ?",
1392 old_ip, new_target_ip_addr));
1394 if (old_ip != new_target_ip_addr)
1397 /* BB lock tcon, server, tcp session and increment use count? */
1398 /* found a match on the TCP session */
1399 /* BB check if reconnection needed */
1400 cFYI(1, ("IP match, old UNC: %s new: %s",
1401 tcon->treeName, uncName));
1403 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1406 cFYI(1, ("and old usr: %s new: %s",
1407 tcon->treeName, uncName));
1409 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1412 /* matched smb session (user name) */
1413 read_unlock(&GlobalSMBSeslock);
1417 read_unlock(&GlobalSMBSeslock);
1422 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1423 const char *old_path, const struct nls_table *nls_codepage,
1426 struct dfs_info3_param *referrals = NULL;
1427 unsigned int num_referrals;
1430 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
1431 &num_referrals, &referrals, remap);
1433 /* BB Add in code to: if valid refrl, if not ip address contact
1434 the helper that resolves tcp names, mount to it, try to
1435 tcon to it unmount it if fail */
1443 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1444 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1445 struct dfs_info3_param **preferrals, int remap)
1449 unsigned char *targetUNCs;
1451 *pnum_referrals = 0;
1454 if (pSesInfo->ipc_tid == 0) {
1455 temp_unc = kmalloc(2 /* for slashes */ +
1456 strnlen(pSesInfo->serverName,
1457 SERVER_NAME_LEN_WITH_NULL * 2)
1458 + 1 + 4 /* slash IPC$ */ + 2,
1460 if (temp_unc == NULL)
1464 strcpy(temp_unc + 2, pSesInfo->serverName);
1465 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1466 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1468 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1472 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
1473 pnum_referrals, nls_codepage, remap);
1474 /* BB map targetUNCs to dfs_info3 structures, here or
1475 in CIFSGetDFSRefer BB */
1480 /* See RFC1001 section 14 on representation of Netbios names */
1481 static void rfc1002mangle(char *target, char *source, unsigned int length)
1485 for (i = 0, j = 0; i < (length); i++) {
1486 /* mask a nibble at a time and encode */
1487 target[j] = 'A' + (0x0F & (source[i] >> 4));
1488 target[j+1] = 'A' + (0x0F & source[i]);
1496 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1497 char *netbios_name, char *target_name)
1501 __be16 orig_port = 0;
1503 if (*csocket == NULL) {
1504 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1505 IPPROTO_TCP, csocket);
1507 cERROR(1, ("Error %d creating socket", rc));
1511 /* BB other socket options to set KEEPALIVE, NODELAY? */
1512 cFYI(1, ("Socket created"));
1513 (*csocket)->sk->sk_allocation = GFP_NOFS;
1517 psin_server->sin_family = AF_INET;
1518 if (psin_server->sin_port) { /* user overrode default port */
1519 rc = (*csocket)->ops->connect(*csocket,
1520 (struct sockaddr *) psin_server,
1521 sizeof(struct sockaddr_in), 0);
1527 /* save original port so we can retry user specified port
1528 later if fall back ports fail this time */
1529 orig_port = psin_server->sin_port;
1531 /* do not retry on the same port we just failed on */
1532 if (psin_server->sin_port != htons(CIFS_PORT)) {
1533 psin_server->sin_port = htons(CIFS_PORT);
1535 rc = (*csocket)->ops->connect(*csocket,
1536 (struct sockaddr *) psin_server,
1537 sizeof(struct sockaddr_in), 0);
1543 psin_server->sin_port = htons(RFC1001_PORT);
1544 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1546 sizeof(struct sockaddr_in), 0);
1551 /* give up here - unless we want to retry on different
1552 protocol families some day */
1555 psin_server->sin_port = orig_port;
1556 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1557 sock_release(*csocket);
1561 /* Eventually check for other socket options to change from
1562 the default. sock_setsockopt not used because it expects
1563 user space buffer */
1564 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1565 (*csocket)->sk->sk_sndbuf,
1566 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1567 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1568 /* make the bufsizes depend on wsize/rsize and max requests */
1569 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1570 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1571 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1572 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1574 /* send RFC1001 sessinit */
1575 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1576 /* some servers require RFC1001 sessinit before sending
1577 negprot - BB check reconnection in case where second
1578 sessinit is sent but no second negprot */
1579 struct rfc1002_session_packet *ses_init_buf;
1580 struct smb_hdr *smb_buf;
1581 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1584 ses_init_buf->trailer.session_req.called_len = 32;
1585 if (target_name && (target_name[0] != 0)) {
1586 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1589 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1590 DEFAULT_CIFS_CALLED_NAME, 16);
1593 ses_init_buf->trailer.session_req.calling_len = 32;
1594 /* calling name ends in null (byte 16) from old smb
1596 if (netbios_name && (netbios_name[0] != 0)) {
1597 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1600 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1601 "LINUX_CIFS_CLNT", 16);
1603 ses_init_buf->trailer.session_req.scope1 = 0;
1604 ses_init_buf->trailer.session_req.scope2 = 0;
1605 smb_buf = (struct smb_hdr *)ses_init_buf;
1606 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1607 smb_buf->smb_buf_length = 0x81000044;
1608 rc = smb_send(*csocket, smb_buf, 0x44,
1609 (struct sockaddr *)psin_server);
1610 kfree(ses_init_buf);
1611 msleep(1); /* RFC1001 layer in at least one server
1612 requires very short break before negprot
1613 presumably because not expecting negprot
1614 to follow so fast. This is a simple
1615 solution that works without
1616 complicating the code and causes no
1617 significant slowing down on mount
1618 for everyone else */
1620 /* else the negprot may still work without this
1621 even though malloc failed */
1629 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1633 __be16 orig_port = 0;
1635 if (*csocket == NULL) {
1636 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1637 IPPROTO_TCP, csocket);
1639 cERROR(1, ("Error %d creating ipv6 socket", rc));
1643 /* BB other socket options to set KEEPALIVE, NODELAY? */
1644 cFYI(1, ("ipv6 Socket created"));
1645 (*csocket)->sk->sk_allocation = GFP_NOFS;
1649 psin_server->sin6_family = AF_INET6;
1651 if (psin_server->sin6_port) { /* user overrode default port */
1652 rc = (*csocket)->ops->connect(*csocket,
1653 (struct sockaddr *) psin_server,
1654 sizeof(struct sockaddr_in6), 0);
1660 /* save original port so we can retry user specified port
1661 later if fall back ports fail this time */
1663 orig_port = psin_server->sin6_port;
1664 /* do not retry on the same port we just failed on */
1665 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1666 psin_server->sin6_port = htons(CIFS_PORT);
1668 rc = (*csocket)->ops->connect(*csocket,
1669 (struct sockaddr *) psin_server,
1670 sizeof(struct sockaddr_in6), 0);
1676 psin_server->sin6_port = htons(RFC1001_PORT);
1677 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1678 psin_server, sizeof(struct sockaddr_in6), 0);
1683 /* give up here - unless we want to retry on different
1684 protocol families some day */
1687 psin_server->sin6_port = orig_port;
1688 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1689 sock_release(*csocket);
1693 /* Eventually check for other socket options to change from
1694 the default. sock_setsockopt not used because it expects
1695 user space buffer */
1696 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1701 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1702 struct super_block *sb, struct smb_vol *vol_info)
1704 /* if we are reconnecting then should we check to see if
1705 * any requested capabilities changed locally e.g. via
1706 * remount but we can not do much about it here
1707 * if they have (even if we could detect it by the following)
1708 * Perhaps we could add a backpointer to array of sb from tcon
1709 * or if we change to make all sb to same share the same
1710 * sb as NFS - then we only have one backpointer to sb.
1711 * What if we wanted to mount the server share twice once with
1712 * and once without posixacls or posix paths? */
1713 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1715 if (vol_info && vol_info->no_linux_ext) {
1716 tcon->fsUnixInfo.Capability = 0;
1717 tcon->unix_ext = 0; /* Unix Extensions disabled */
1718 cFYI(1, ("Linux protocol extensions disabled"));
1720 } else if (vol_info)
1721 tcon->unix_ext = 1; /* Unix Extensions supported */
1723 if (tcon->unix_ext == 0) {
1724 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1728 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1729 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1731 /* check for reconnect case in which we do not
1732 want to change the mount behavior if we can avoid it */
1733 if (vol_info == NULL) {
1734 /* turn off POSIX ACL and PATHNAMES if not set
1735 originally at mount time */
1736 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1737 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1738 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1739 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1740 cERROR(1, ("POSIXPATH support change"));
1741 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1742 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1743 cERROR(1, ("possible reconnect error"));
1745 ("server disabled POSIX path support"));
1749 cap &= CIFS_UNIX_CAP_MASK;
1750 if (vol_info && vol_info->no_psx_acl)
1751 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1752 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1753 cFYI(1, ("negotiated posix acl support"));
1755 sb->s_flags |= MS_POSIXACL;
1758 if (vol_info && vol_info->posix_paths == 0)
1759 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1760 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1761 cFYI(1, ("negotiate posix pathnames"));
1763 CIFS_SB(sb)->mnt_cifs_flags |=
1764 CIFS_MOUNT_POSIX_PATHS;
1767 /* We might be setting the path sep back to a different
1768 form if we are reconnecting and the server switched its
1769 posix path capability for this share */
1770 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1771 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1773 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1774 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1775 CIFS_SB(sb)->rsize = 127 * 1024;
1777 ("larger reads not supported by srv"));
1782 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1783 #ifdef CONFIG_CIFS_DEBUG2
1784 if (cap & CIFS_UNIX_FCNTL_CAP)
1785 cFYI(1, ("FCNTL cap"));
1786 if (cap & CIFS_UNIX_EXTATTR_CAP)
1787 cFYI(1, ("EXTATTR cap"));
1788 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1789 cFYI(1, ("POSIX path cap"));
1790 if (cap & CIFS_UNIX_XATTR_CAP)
1791 cFYI(1, ("XATTR cap"));
1792 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1793 cFYI(1, ("POSIX ACL cap"));
1794 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1795 cFYI(1, ("very large read cap"));
1796 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1797 cFYI(1, ("very large write cap"));
1798 #endif /* CIFS_DEBUG2 */
1799 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1800 if (vol_info == NULL) {
1801 cFYI(1, ("resetting capabilities failed"));
1803 cERROR(1, ("Negotiating Unix capabilities "
1804 "with the server failed. Consider "
1805 "mounting with the Unix Extensions\n"
1806 "disabled, if problems are found, "
1807 "by specifying the nounix mount "
1815 convert_delimiter(char *path, char delim)
1828 for (i = 0; path[i] != '\0'; i++) {
1829 if (path[i] == old_delim)
1835 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1836 char *mount_data, const char *devname)
1840 int address_type = AF_INET;
1841 struct socket *csocket = NULL;
1842 struct sockaddr_in sin_server;
1843 struct sockaddr_in6 sin_server6;
1844 struct smb_vol volume_info;
1845 struct cifsSesInfo *pSesInfo = NULL;
1846 struct cifsSesInfo *existingCifsSes = NULL;
1847 struct cifsTconInfo *tcon = NULL;
1848 struct TCP_Server_Info *srvTcp = NULL;
1852 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1854 memset(&volume_info, 0, sizeof(struct smb_vol));
1855 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1860 if (volume_info.nullauth) {
1861 cFYI(1, ("null user"));
1862 volume_info.username = "";
1863 } else if (volume_info.username) {
1864 /* BB fixme parse for domain name here */
1865 cFYI(1, ("Username: %s", volume_info.username));
1867 cifserror("No username specified");
1868 /* In userspace mount helper we can get user name from alternate
1869 locations such as env variables and files on disk */
1874 if (volume_info.UNCip && volume_info.UNC) {
1875 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1876 &sin_server.sin_addr.s_addr);
1879 /* not ipv4 address, try ipv6 */
1880 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1881 &sin_server6.sin6_addr.in6_u);
1883 address_type = AF_INET6;
1885 address_type = AF_INET;
1889 /* we failed translating address */
1894 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1897 } else if (volume_info.UNCip) {
1898 /* BB using ip addr as server name to connect to the
1900 cERROR(1, ("Connecting to DFS root not implemented yet"));
1903 } else /* which servers DFS root would we conect to */ {
1905 ("CIFS mount error: No UNC path (e.g. -o "
1906 "unc=//192.168.1.100/public) specified"));
1911 /* this is needed for ASCII cp to Unicode converts */
1912 if (volume_info.iocharset == NULL) {
1913 cifs_sb->local_nls = load_nls_default();
1914 /* load_nls_default can not return null */
1916 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1917 if (cifs_sb->local_nls == NULL) {
1918 cERROR(1, ("CIFS mount error: iocharset %s not found",
1919 volume_info.iocharset));
1925 if (address_type == AF_INET)
1926 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1927 NULL /* no ipv6 addr */,
1928 volume_info.username, &srvTcp);
1929 else if (address_type == AF_INET6) {
1930 cFYI(1, ("looking for ipv6 address"));
1931 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1932 &sin_server6.sin6_addr,
1933 volume_info.username, &srvTcp);
1940 cFYI(1, ("Existing tcp session with server found"));
1941 } else { /* create socket */
1942 if (volume_info.port)
1943 sin_server.sin_port = htons(volume_info.port);
1945 sin_server.sin_port = 0;
1946 if (address_type == AF_INET6) {
1947 cFYI(1, ("attempting ipv6 connect"));
1948 /* BB should we allow ipv6 on port 139? */
1949 /* other OS never observed in Wild doing 139 with v6 */
1950 rc = ipv6_connect(&sin_server6, &csocket);
1952 rc = ipv4_connect(&sin_server, &csocket,
1953 volume_info.source_rfc1001_name,
1954 volume_info.target_rfc1001_name);
1956 cERROR(1, ("Error connecting to IPv4 socket. "
1957 "Aborting operation"));
1958 if (csocket != NULL)
1959 sock_release(csocket);
1963 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1966 sock_release(csocket);
1969 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1970 sizeof(struct sockaddr_in));
1971 atomic_set(&srvTcp->inFlight, 0);
1972 /* BB Add code for ipv6 case too */
1973 srvTcp->ssocket = csocket;
1974 srvTcp->protocolType = IPV4;
1975 srvTcp->hostname = extract_hostname(volume_info.UNC);
1976 if (IS_ERR(srvTcp->hostname)) {
1977 rc = PTR_ERR(srvTcp->hostname);
1978 sock_release(csocket);
1981 init_waitqueue_head(&srvTcp->response_q);
1982 init_waitqueue_head(&srvTcp->request_q);
1983 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1984 /* at this point we are the only ones with the pointer
1985 to the struct since the kernel thread not created yet
1986 so no need to spinlock this init of tcpStatus */
1987 srvTcp->tcpStatus = CifsNew;
1988 init_MUTEX(&srvTcp->tcpSem);
1989 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1990 if (IS_ERR(srvTcp->tsk)) {
1991 rc = PTR_ERR(srvTcp->tsk);
1992 cERROR(1, ("error %d create cifsd thread", rc));
1994 sock_release(csocket);
1995 kfree(srvTcp->hostname);
1999 memcpy(srvTcp->workstation_RFC1001_name,
2000 volume_info.source_rfc1001_name, 16);
2001 memcpy(srvTcp->server_RFC1001_name,
2002 volume_info.target_rfc1001_name, 16);
2003 srvTcp->sequence_number = 0;
2007 if (existingCifsSes) {
2008 pSesInfo = existingCifsSes;
2009 cFYI(1, ("Existing smb sess found (status=%d)",
2011 down(&pSesInfo->sesSem);
2012 if (pSesInfo->status == CifsNeedReconnect) {
2013 cFYI(1, ("Session needs reconnect"));
2014 rc = cifs_setup_session(xid, pSesInfo,
2015 cifs_sb->local_nls);
2017 up(&pSesInfo->sesSem);
2019 cFYI(1, ("Existing smb sess not found"));
2020 pSesInfo = sesInfoAlloc();
2021 if (pSesInfo == NULL)
2024 pSesInfo->server = srvTcp;
2025 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2026 NIPQUAD(sin_server.sin_addr.s_addr));
2030 /* volume_info.password freed at unmount */
2031 if (volume_info.password) {
2032 pSesInfo->password = volume_info.password;
2033 /* set to NULL to prevent freeing on exit */
2034 volume_info.password = NULL;
2036 if (volume_info.username)
2037 strncpy(pSesInfo->userName,
2038 volume_info.username,
2040 if (volume_info.domainname) {
2041 int len = strlen(volume_info.domainname);
2042 pSesInfo->domainName =
2043 kmalloc(len + 1, GFP_KERNEL);
2044 if (pSesInfo->domainName)
2045 strcpy(pSesInfo->domainName,
2046 volume_info.domainname);
2048 pSesInfo->linux_uid = volume_info.linux_uid;
2049 pSesInfo->overrideSecFlg = volume_info.secFlg;
2050 down(&pSesInfo->sesSem);
2051 /* BB FIXME need to pass vol->secFlgs BB */
2052 rc = cifs_setup_session(xid, pSesInfo,
2053 cifs_sb->local_nls);
2054 up(&pSesInfo->sesSem);
2056 atomic_inc(&srvTcp->socketUseCount);
2060 /* search for existing tcon to this server share */
2062 if (volume_info.rsize > CIFSMaxBufSize) {
2063 cERROR(1, ("rsize %d too large, using MaxBufSize",
2064 volume_info.rsize));
2065 cifs_sb->rsize = CIFSMaxBufSize;
2066 } else if ((volume_info.rsize) &&
2067 (volume_info.rsize <= CIFSMaxBufSize))
2068 cifs_sb->rsize = volume_info.rsize;
2070 cifs_sb->rsize = CIFSMaxBufSize;
2072 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2073 cERROR(1, ("wsize %d too large, using 4096 instead",
2074 volume_info.wsize));
2075 cifs_sb->wsize = 4096;
2076 } else if (volume_info.wsize)
2077 cifs_sb->wsize = volume_info.wsize;
2080 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2082 /* old default of CIFSMaxBufSize was too small now
2083 that SMB Write2 can send multiple pages in kvec.
2084 RFC1001 does not describe what happens when frame
2085 bigger than 128K is sent so use that as max in
2086 conjunction with 52K kvec constraint on arch with 4K
2089 if (cifs_sb->rsize < 2048) {
2090 cifs_sb->rsize = 2048;
2091 /* Windows ME may prefer this */
2092 cFYI(1, ("readsize set to minimum: 2048"));
2094 /* calculate prepath */
2095 cifs_sb->prepath = volume_info.prepath;
2096 if (cifs_sb->prepath) {
2097 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2098 /* we can not convert the / to \ in the path
2099 separators in the prefixpath yet because we do not
2100 know (until reset_cifs_unix_caps is called later)
2101 whether POSIX PATH CAP is available. We normalize
2102 the / to \ after reset_cifs_unix_caps is called */
2103 volume_info.prepath = NULL;
2105 cifs_sb->prepathlen = 0;
2106 cifs_sb->mnt_uid = volume_info.linux_uid;
2107 cifs_sb->mnt_gid = volume_info.linux_gid;
2108 cifs_sb->mnt_file_mode = volume_info.file_mode;
2109 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2110 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2111 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2113 if (volume_info.noperm)
2114 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2115 if (volume_info.setuids)
2116 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2117 if (volume_info.server_ino)
2118 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2119 if (volume_info.remap)
2120 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2121 if (volume_info.no_xattr)
2122 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2123 if (volume_info.sfu_emul)
2124 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2125 if (volume_info.nobrl)
2126 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2127 if (volume_info.cifs_acl)
2128 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2129 if (volume_info.override_uid)
2130 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2131 if (volume_info.override_gid)
2132 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2133 if (volume_info.dynperm)
2134 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2135 if (volume_info.direct_io) {
2136 cFYI(1, ("mounting share using direct i/o"));
2137 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2141 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2142 volume_info.username);
2144 cFYI(1, ("Found match on UNC path"));
2145 /* we can have only one retry value for a connection
2146 to a share so for resources mounted more than once
2147 to the same server share the last value passed in
2148 for the retry flag is used */
2149 tcon->retry = volume_info.retry;
2150 tcon->nocase = volume_info.nocase;
2152 tcon = tconInfoAlloc();
2156 /* check for null share name ie connecting to
2159 /* BB check if this works for exactly length
2161 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2162 && (strchr(volume_info.UNC + 3, '/') ==
2164 rc = connect_to_dfs_path(xid, pSesInfo,
2165 "", cifs_sb->local_nls,
2166 cifs_sb->mnt_cifs_flags &
2167 CIFS_MOUNT_MAP_SPECIAL_CHR);
2171 /* BB Do we need to wrap sesSem around
2172 * this TCon call and Unix SetFS as
2173 * we do on SessSetup and reconnect? */
2174 rc = CIFSTCon(xid, pSesInfo,
2176 tcon, cifs_sb->local_nls);
2177 cFYI(1, ("CIFS Tcon rc = %d", rc));
2180 atomic_inc(&pSesInfo->inUse);
2181 tcon->retry = volume_info.retry;
2182 tcon->nocase = volume_info.nocase;
2188 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2189 sb->s_maxbytes = (u64) 1 << 63;
2191 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2194 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2195 sb->s_time_gran = 100;
2197 /* on error free sesinfo and tcon struct if needed */
2199 /* if session setup failed, use count is zero but
2200 we still need to free cifsd thread */
2201 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2202 spin_lock(&GlobalMid_Lock);
2203 srvTcp->tcpStatus = CifsExiting;
2204 spin_unlock(&GlobalMid_Lock);
2206 /* If we could verify that kthread_stop would
2207 always wake up processes blocked in
2208 tcp in recv_mesg then we could remove the
2210 force_sig(SIGKILL, srvTcp->tsk);
2211 kthread_stop(srvTcp->tsk);
2214 /* If find_unc succeeded then rc == 0 so we can not end */
2215 if (tcon) /* up accidently freeing someone elses tcon struct */
2217 if (existingCifsSes == NULL) {
2219 if ((pSesInfo->server) &&
2220 (pSesInfo->status == CifsGood)) {
2222 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2223 /* if the socketUseCount is now zero */
2224 if ((temp_rc == -ESHUTDOWN) &&
2225 (pSesInfo->server) &&
2226 (pSesInfo->server->tsk)) {
2228 pSesInfo->server->tsk);
2229 kthread_stop(pSesInfo->server->tsk);
2232 cFYI(1, ("No session or bad tcon"));
2233 if ((pSesInfo->server) &&
2234 (pSesInfo->server->tsk)) {
2236 pSesInfo->server->tsk);
2237 kthread_stop(pSesInfo->server->tsk);
2240 sesInfoFree(pSesInfo);
2241 /* pSesInfo = NULL; */
2245 atomic_inc(&tcon->useCount);
2246 cifs_sb->tcon = tcon;
2247 tcon->ses = pSesInfo;
2249 /* do not care if following two calls succeed - informational */
2251 CIFSSMBQFSDeviceInfo(xid, tcon);
2252 CIFSSMBQFSAttributeInfo(xid, tcon);
2255 /* tell server which Unix caps we support */
2256 if (tcon->ses->capabilities & CAP_UNIX)
2257 /* reset of caps checks mount to see if unix extensions
2258 disabled for just this mount */
2259 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2261 tcon->unix_ext = 0; /* server does not support them */
2263 /* convert forward to back slashes in prepath here if needed */
2264 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2265 convert_delimiter(cifs_sb->prepath,
2266 CIFS_DIR_SEP(cifs_sb));
2268 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2269 cifs_sb->rsize = 1024 * 127;
2271 ("no very large read support, rsize now 127K"));
2273 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2274 cifs_sb->wsize = min(cifs_sb->wsize,
2275 (tcon->ses->server->maxBuf -
2276 MAX_CIFS_HDR_SIZE));
2277 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2278 cifs_sb->rsize = min(cifs_sb->rsize,
2279 (tcon->ses->server->maxBuf -
2280 MAX_CIFS_HDR_SIZE));
2283 /* volume_info.password is freed above when existing session found
2284 (in which case it is not needed anymore) but when new sesion is created
2285 the password ptr is put in the new session structure (in which case the
2286 password will be freed at unmount time) */
2288 /* zero out password before freeing */
2289 if (volume_info.password != NULL) {
2290 memset(volume_info.password, 0, strlen(volume_info.password));
2291 kfree(volume_info.password);
2293 kfree(volume_info.UNC);
2294 kfree(volume_info.prepath);
2300 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2301 char session_key[CIFS_SESS_KEY_SIZE],
2302 const struct nls_table *nls_codepage)
2304 struct smb_hdr *smb_buffer;
2305 struct smb_hdr *smb_buffer_response;
2306 SESSION_SETUP_ANDX *pSMB;
2307 SESSION_SETUP_ANDX *pSMBr;
2312 int remaining_words = 0;
2313 int bytes_returned = 0;
2318 cFYI(1, ("In sesssetup"));
2321 user = ses->userName;
2322 domain = ses->domainName;
2323 smb_buffer = cifs_buf_get();
2324 if (smb_buffer == NULL) {
2327 smb_buffer_response = smb_buffer;
2328 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2330 /* send SMBsessionSetup here */
2331 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2332 NULL /* no tCon exists yet */ , 13 /* wct */ );
2334 smb_buffer->Mid = GetNextMid(ses->server);
2335 pSMB->req_no_secext.AndXCommand = 0xFF;
2336 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2337 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2339 if (ses->server->secMode &
2340 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2341 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2343 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2344 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2345 if (ses->capabilities & CAP_UNICODE) {
2346 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2347 capabilities |= CAP_UNICODE;
2349 if (ses->capabilities & CAP_STATUS32) {
2350 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2351 capabilities |= CAP_STATUS32;
2353 if (ses->capabilities & CAP_DFS) {
2354 smb_buffer->Flags2 |= SMBFLG2_DFS;
2355 capabilities |= CAP_DFS;
2357 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2359 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2360 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2362 pSMB->req_no_secext.CaseSensitivePasswordLength =
2363 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2364 bcc_ptr = pByteArea(smb_buffer);
2365 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2366 bcc_ptr += CIFS_SESS_KEY_SIZE;
2367 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2368 bcc_ptr += CIFS_SESS_KEY_SIZE;
2370 if (ses->capabilities & CAP_UNICODE) {
2371 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2376 bytes_returned = 0; /* skip null user */
2379 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2381 /* convert number of 16 bit words to bytes */
2382 bcc_ptr += 2 * bytes_returned;
2383 bcc_ptr += 2; /* trailing null */
2386 cifs_strtoUCS((__le16 *) bcc_ptr,
2387 "CIFS_LINUX_DOM", 32, nls_codepage);
2390 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2392 bcc_ptr += 2 * bytes_returned;
2395 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2397 bcc_ptr += 2 * bytes_returned;
2399 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2401 bcc_ptr += 2 * bytes_returned;
2404 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2406 bcc_ptr += 2 * bytes_returned;
2410 strncpy(bcc_ptr, user, 200);
2411 bcc_ptr += strnlen(user, 200);
2415 if (domain == NULL) {
2416 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2417 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2419 strncpy(bcc_ptr, domain, 64);
2420 bcc_ptr += strnlen(domain, 64);
2424 strcpy(bcc_ptr, "Linux version ");
2425 bcc_ptr += strlen("Linux version ");
2426 strcpy(bcc_ptr, utsname()->release);
2427 bcc_ptr += strlen(utsname()->release) + 1;
2428 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2429 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2431 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2432 smb_buffer->smb_buf_length += count;
2433 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2435 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2436 &bytes_returned, CIFS_LONG_OP);
2438 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2439 } else if ((smb_buffer_response->WordCount == 3)
2440 || (smb_buffer_response->WordCount == 4)) {
2441 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2442 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2443 if (action & GUEST_LOGIN)
2444 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2445 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2447 cFYI(1, ("UID = %d ", ses->Suid));
2448 /* response can have either 3 or 4 word count - Samba sends 3 */
2449 bcc_ptr = pByteArea(smb_buffer_response);
2450 if ((pSMBr->resp.hdr.WordCount == 3)
2451 || ((pSMBr->resp.hdr.WordCount == 4)
2452 && (blob_len < pSMBr->resp.ByteCount))) {
2453 if (pSMBr->resp.hdr.WordCount == 4)
2454 bcc_ptr += blob_len;
2456 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2457 if ((long) (bcc_ptr) % 2) {
2459 (BCC(smb_buffer_response) - 1) / 2;
2460 /* Unicode strings must be word
2465 BCC(smb_buffer_response) / 2;
2468 UniStrnlen((wchar_t *) bcc_ptr,
2469 remaining_words - 1);
2470 /* We look for obvious messed up bcc or strings in response so we do not go off
2471 the end since (at least) WIN2K and Windows XP have a major bug in not null
2472 terminating last Unicode string in response */
2474 kfree(ses->serverOS);
2475 ses->serverOS = kzalloc(2 * (len + 1),
2477 if (ses->serverOS == NULL)
2478 goto sesssetup_nomem;
2479 cifs_strfromUCS_le(ses->serverOS,
2482 bcc_ptr += 2 * (len + 1);
2483 remaining_words -= len + 1;
2484 ses->serverOS[2 * len] = 0;
2485 ses->serverOS[1 + (2 * len)] = 0;
2486 if (remaining_words > 0) {
2487 len = UniStrnlen((wchar_t *)bcc_ptr,
2489 kfree(ses->serverNOS);
2490 ses->serverNOS = kzalloc(2 * (len + 1),
2492 if (ses->serverNOS == NULL)
2493 goto sesssetup_nomem;
2494 cifs_strfromUCS_le(ses->serverNOS,
2497 bcc_ptr += 2 * (len + 1);
2498 ses->serverNOS[2 * len] = 0;
2499 ses->serverNOS[1 + (2 * len)] = 0;
2500 if (strncmp(ses->serverNOS,
2501 "NT LAN Manager 4", 16) == 0) {
2502 cFYI(1, ("NT4 server"));
2503 ses->flags |= CIFS_SES_NT4;
2505 remaining_words -= len + 1;
2506 if (remaining_words > 0) {
2507 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2508 /* last string is not always null terminated
2509 (for e.g. for Windows XP & 2000) */
2510 if (ses->serverDomain)
2511 kfree(ses->serverDomain);
2515 if (ses->serverDomain == NULL)
2516 goto sesssetup_nomem;
2517 cifs_strfromUCS_le(ses->serverDomain,
2520 bcc_ptr += 2 * (len + 1);
2521 ses->serverDomain[2*len] = 0;
2522 ses->serverDomain[1+(2*len)] = 0;
2523 } else { /* else no more room so create
2524 dummy domain string */
2525 if (ses->serverDomain)
2526 kfree(ses->serverDomain);
2528 kzalloc(2, GFP_KERNEL);
2530 } else { /* no room so create dummy domain
2533 /* if these kcallocs fail not much we
2534 can do, but better to not fail the
2536 kfree(ses->serverDomain);
2538 kzalloc(2, GFP_KERNEL);
2539 kfree(ses->serverNOS);
2541 kzalloc(2, GFP_KERNEL);
2543 } else { /* ASCII */
2544 len = strnlen(bcc_ptr, 1024);
2545 if (((long) bcc_ptr + len) - (long)
2546 pByteArea(smb_buffer_response)
2547 <= BCC(smb_buffer_response)) {
2548 kfree(ses->serverOS);
2549 ses->serverOS = kzalloc(len + 1,
2551 if (ses->serverOS == NULL)
2552 goto sesssetup_nomem;
2553 strncpy(ses->serverOS, bcc_ptr, len);
2556 /* null terminate the string */
2560 len = strnlen(bcc_ptr, 1024);
2561 kfree(ses->serverNOS);
2562 ses->serverNOS = kzalloc(len + 1,
2564 if (ses->serverNOS == NULL)
2565 goto sesssetup_nomem;
2566 strncpy(ses->serverNOS, bcc_ptr, len);
2571 len = strnlen(bcc_ptr, 1024);
2572 if (ses->serverDomain)
2573 kfree(ses->serverDomain);
2574 ses->serverDomain = kzalloc(len + 1,
2576 if (ses->serverDomain == NULL)
2577 goto sesssetup_nomem;
2578 strncpy(ses->serverDomain, bcc_ptr,
2585 ("Variable field of length %d "
2586 "extends beyond end of smb ",
2591 (" Security Blob Length extends beyond "
2596 (" Invalid Word count %d: ",
2597 smb_buffer_response->WordCount));
2600 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2601 since that could make reconnection harder, and
2602 reconnection might be needed to free memory */
2603 cifs_buf_release(smb_buffer);
2609 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2610 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2611 const struct nls_table *nls_codepage)
2613 struct smb_hdr *smb_buffer;
2614 struct smb_hdr *smb_buffer_response;
2615 SESSION_SETUP_ANDX *pSMB;
2616 SESSION_SETUP_ANDX *pSMBr;
2620 int remaining_words = 0;
2621 int bytes_returned = 0;
2623 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2624 PNEGOTIATE_MESSAGE SecurityBlob;
2625 PCHALLENGE_MESSAGE SecurityBlob2;
2626 __u32 negotiate_flags, capabilities;
2629 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2632 domain = ses->domainName;
2633 *pNTLMv2_flag = false;
2634 smb_buffer = cifs_buf_get();
2635 if (smb_buffer == NULL) {
2638 smb_buffer_response = smb_buffer;
2639 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2640 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2642 /* send SMBsessionSetup here */
2643 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2644 NULL /* no tCon exists yet */ , 12 /* wct */ );
2646 smb_buffer->Mid = GetNextMid(ses->server);
2647 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2648 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2650 pSMB->req.AndXCommand = 0xFF;
2651 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2652 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2654 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2655 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2657 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2658 CAP_EXTENDED_SECURITY;
2659 if (ses->capabilities & CAP_UNICODE) {
2660 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2661 capabilities |= CAP_UNICODE;
2663 if (ses->capabilities & CAP_STATUS32) {
2664 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2665 capabilities |= CAP_STATUS32;
2667 if (ses->capabilities & CAP_DFS) {
2668 smb_buffer->Flags2 |= SMBFLG2_DFS;
2669 capabilities |= CAP_DFS;
2671 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2673 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2674 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2675 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2676 SecurityBlob->MessageType = NtLmNegotiate;
2678 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2679 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2680 NTLMSSP_NEGOTIATE_56 |
2681 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2683 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2684 /* if (ntlmv2_support)
2685 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2686 /* setup pointers to domain name and workstation name */
2687 bcc_ptr += SecurityBlobLength;
2689 SecurityBlob->WorkstationName.Buffer = 0;
2690 SecurityBlob->WorkstationName.Length = 0;
2691 SecurityBlob->WorkstationName.MaximumLength = 0;
2693 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2694 along with username on auth request (ie the response to challenge) */
2695 SecurityBlob->DomainName.Buffer = 0;
2696 SecurityBlob->DomainName.Length = 0;
2697 SecurityBlob->DomainName.MaximumLength = 0;
2698 if (ses->capabilities & CAP_UNICODE) {
2699 if ((long) bcc_ptr % 2) {
2705 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2707 bcc_ptr += 2 * bytes_returned;
2709 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2711 bcc_ptr += 2 * bytes_returned;
2712 bcc_ptr += 2; /* null terminate Linux version */
2714 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2716 bcc_ptr += 2 * bytes_returned;
2719 bcc_ptr += 2; /* null terminate network opsys string */
2722 bcc_ptr += 2; /* null domain */
2723 } else { /* ASCII */
2724 strcpy(bcc_ptr, "Linux version ");
2725 bcc_ptr += strlen("Linux version ");
2726 strcpy(bcc_ptr, utsname()->release);
2727 bcc_ptr += strlen(utsname()->release) + 1;
2728 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2729 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2730 bcc_ptr++; /* empty domain field */
2733 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2734 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2735 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2736 smb_buffer->smb_buf_length += count;
2737 pSMB->req.ByteCount = cpu_to_le16(count);
2739 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2740 &bytes_returned, CIFS_LONG_OP);
2742 if (smb_buffer_response->Status.CifsError ==
2743 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2747 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2748 } else if ((smb_buffer_response->WordCount == 3)
2749 || (smb_buffer_response->WordCount == 4)) {
2750 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2751 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2753 if (action & GUEST_LOGIN)
2754 cFYI(1, (" Guest login"));
2755 /* Do we want to set anything in SesInfo struct when guest login? */
2757 bcc_ptr = pByteArea(smb_buffer_response);
2758 /* response can have either 3 or 4 word count - Samba sends 3 */
2760 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2761 if (SecurityBlob2->MessageType != NtLmChallenge) {
2763 ("Unexpected NTLMSSP message type received %d",
2764 SecurityBlob2->MessageType));
2766 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2767 cFYI(1, ("UID = %d", ses->Suid));
2768 if ((pSMBr->resp.hdr.WordCount == 3)
2769 || ((pSMBr->resp.hdr.WordCount == 4)
2771 pSMBr->resp.ByteCount))) {
2773 if (pSMBr->resp.hdr.WordCount == 4) {
2774 bcc_ptr += blob_len;
2775 cFYI(1, ("Security Blob Length %d",
2779 cFYI(1, ("NTLMSSP Challenge rcvd"));
2781 memcpy(ses->server->cryptKey,
2782 SecurityBlob2->Challenge,
2783 CIFS_CRYPTO_KEY_SIZE);
2784 if (SecurityBlob2->NegotiateFlags &
2785 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2786 *pNTLMv2_flag = true;
2788 if ((SecurityBlob2->NegotiateFlags &
2789 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2790 || (sign_CIFS_PDUs > 1))
2791 ses->server->secMode |=
2792 SECMODE_SIGN_REQUIRED;
2793 if ((SecurityBlob2->NegotiateFlags &
2794 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2795 ses->server->secMode |=
2796 SECMODE_SIGN_ENABLED;
2798 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2799 if ((long) (bcc_ptr) % 2) {
2801 (BCC(smb_buffer_response)
2803 /* Must word align unicode strings */
2808 (smb_buffer_response) / 2;
2811 UniStrnlen((wchar_t *) bcc_ptr,
2812 remaining_words - 1);
2813 /* We look for obvious messed up bcc or strings in response so we do not go off
2814 the end since (at least) WIN2K and Windows XP have a major bug in not null
2815 terminating last Unicode string in response */
2817 kfree(ses->serverOS);
2819 kzalloc(2 * (len + 1), GFP_KERNEL);
2820 cifs_strfromUCS_le(ses->serverOS,
2824 bcc_ptr += 2 * (len + 1);
2825 remaining_words -= len + 1;
2826 ses->serverOS[2 * len] = 0;
2827 ses->serverOS[1 + (2 * len)] = 0;
2828 if (remaining_words > 0) {
2829 len = UniStrnlen((wchar_t *)
2833 kfree(ses->serverNOS);
2835 kzalloc(2 * (len + 1),
2837 cifs_strfromUCS_le(ses->
2843 bcc_ptr += 2 * (len + 1);
2844 ses->serverNOS[2 * len] = 0;
2847 remaining_words -= len + 1;
2848 if (remaining_words > 0) {
2849 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2850 /* last string not always null terminated
2851 (for e.g. for Windows XP & 2000) */
2852 kfree(ses->serverDomain);
2864 ses->serverDomain[2*len]
2869 } /* else no more room so create dummy domain string */
2871 kfree(ses->serverDomain);
2876 } else { /* no room so create dummy domain and NOS string */
2877 kfree(ses->serverDomain);
2879 kzalloc(2, GFP_KERNEL);
2880 kfree(ses->serverNOS);
2882 kzalloc(2, GFP_KERNEL);
2884 } else { /* ASCII */
2885 len = strnlen(bcc_ptr, 1024);
2886 if (((long) bcc_ptr + len) - (long)
2887 pByteArea(smb_buffer_response)
2888 <= BCC(smb_buffer_response)) {
2890 kfree(ses->serverOS);
2894 strncpy(ses->serverOS,
2898 bcc_ptr[0] = 0; /* null terminate string */
2901 len = strnlen(bcc_ptr, 1024);
2902 kfree(ses->serverNOS);
2906 strncpy(ses->serverNOS, bcc_ptr, len);
2911 len = strnlen(bcc_ptr, 1024);
2912 kfree(ses->serverDomain);
2916 strncpy(ses->serverDomain,
2923 ("field of length %d "
2924 "extends beyond end of smb",
2928 cERROR(1, ("Security Blob Length extends beyond"
2932 cERROR(1, ("No session structure passed in."));
2936 (" Invalid Word count %d:",
2937 smb_buffer_response->WordCount));
2941 cifs_buf_release(smb_buffer);
2946 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2947 char *ntlm_session_key, bool ntlmv2_flag,
2948 const struct nls_table *nls_codepage)
2950 struct smb_hdr *smb_buffer;
2951 struct smb_hdr *smb_buffer_response;
2952 SESSION_SETUP_ANDX *pSMB;
2953 SESSION_SETUP_ANDX *pSMBr;
2958 int remaining_words = 0;
2959 int bytes_returned = 0;
2961 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2962 PAUTHENTICATE_MESSAGE SecurityBlob;
2963 __u32 negotiate_flags, capabilities;
2966 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2969 user = ses->userName;
2970 domain = ses->domainName;
2971 smb_buffer = cifs_buf_get();
2972 if (smb_buffer == NULL) {
2975 smb_buffer_response = smb_buffer;
2976 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2977 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2979 /* send SMBsessionSetup here */
2980 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2981 NULL /* no tCon exists yet */ , 12 /* wct */ );
2983 smb_buffer->Mid = GetNextMid(ses->server);
2984 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2985 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2986 pSMB->req.AndXCommand = 0xFF;
2987 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2988 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2990 pSMB->req.hdr.Uid = ses->Suid;
2992 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2993 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2995 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2996 CAP_EXTENDED_SECURITY;
2997 if (ses->capabilities & CAP_UNICODE) {
2998 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2999 capabilities |= CAP_UNICODE;
3001 if (ses->capabilities & CAP_STATUS32) {
3002 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3003 capabilities |= CAP_STATUS32;
3005 if (ses->capabilities & CAP_DFS) {
3006 smb_buffer->Flags2 |= SMBFLG2_DFS;
3007 capabilities |= CAP_DFS;
3009 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3011 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3012 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3013 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3014 SecurityBlob->MessageType = NtLmAuthenticate;
3015 bcc_ptr += SecurityBlobLength;
3016 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3017 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3018 0x80000000 | NTLMSSP_NEGOTIATE_128;
3020 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3022 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3024 /* setup pointers to domain name and workstation name */
3026 SecurityBlob->WorkstationName.Buffer = 0;
3027 SecurityBlob->WorkstationName.Length = 0;
3028 SecurityBlob->WorkstationName.MaximumLength = 0;
3029 SecurityBlob->SessionKey.Length = 0;
3030 SecurityBlob->SessionKey.MaximumLength = 0;
3031 SecurityBlob->SessionKey.Buffer = 0;
3033 SecurityBlob->LmChallengeResponse.Length = 0;
3034 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3035 SecurityBlob->LmChallengeResponse.Buffer = 0;
3037 SecurityBlob->NtChallengeResponse.Length =
3038 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3039 SecurityBlob->NtChallengeResponse.MaximumLength =
3040 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3041 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3042 SecurityBlob->NtChallengeResponse.Buffer =
3043 cpu_to_le32(SecurityBlobLength);
3044 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3045 bcc_ptr += CIFS_SESS_KEY_SIZE;
3047 if (ses->capabilities & CAP_UNICODE) {
3048 if (domain == NULL) {
3049 SecurityBlob->DomainName.Buffer = 0;
3050 SecurityBlob->DomainName.Length = 0;
3051 SecurityBlob->DomainName.MaximumLength = 0;
3053 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3056 SecurityBlob->DomainName.MaximumLength =
3058 SecurityBlob->DomainName.Buffer =
3059 cpu_to_le32(SecurityBlobLength);
3061 SecurityBlobLength += ln;
3062 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3065 SecurityBlob->UserName.Buffer = 0;
3066 SecurityBlob->UserName.Length = 0;
3067 SecurityBlob->UserName.MaximumLength = 0;
3069 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3072 SecurityBlob->UserName.MaximumLength =
3074 SecurityBlob->UserName.Buffer =
3075 cpu_to_le32(SecurityBlobLength);
3077 SecurityBlobLength += ln;
3078 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3081 /* SecurityBlob->WorkstationName.Length =
3082 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3083 SecurityBlob->WorkstationName.Length *= 2;
3084 SecurityBlob->WorkstationName.MaximumLength =
3085 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3086 SecurityBlob->WorkstationName.Buffer =
3087 cpu_to_le32(SecurityBlobLength);
3088 bcc_ptr += SecurityBlob->WorkstationName.Length;
3089 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3090 SecurityBlob->WorkstationName.Length =
3091 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3093 if ((long) bcc_ptr % 2) {
3098 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3100 bcc_ptr += 2 * bytes_returned;
3102 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3104 bcc_ptr += 2 * bytes_returned;
3105 bcc_ptr += 2; /* null term version string */
3107 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3109 bcc_ptr += 2 * bytes_returned;
3112 bcc_ptr += 2; /* null terminate network opsys string */
3115 bcc_ptr += 2; /* null domain */
3116 } else { /* ASCII */
3117 if (domain == NULL) {
3118 SecurityBlob->DomainName.Buffer = 0;
3119 SecurityBlob->DomainName.Length = 0;
3120 SecurityBlob->DomainName.MaximumLength = 0;
3123 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3124 strncpy(bcc_ptr, domain, 63);
3125 ln = strnlen(domain, 64);
3126 SecurityBlob->DomainName.MaximumLength =
3128 SecurityBlob->DomainName.Buffer =
3129 cpu_to_le32(SecurityBlobLength);
3131 SecurityBlobLength += ln;
3132 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3135 SecurityBlob->UserName.Buffer = 0;
3136 SecurityBlob->UserName.Length = 0;
3137 SecurityBlob->UserName.MaximumLength = 0;
3140 strncpy(bcc_ptr, user, 63);
3141 ln = strnlen(user, 64);
3142 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3143 SecurityBlob->UserName.Buffer =
3144 cpu_to_le32(SecurityBlobLength);
3146 SecurityBlobLength += ln;
3147 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3149 /* BB fill in our workstation name if known BB */
3151 strcpy(bcc_ptr, "Linux version ");
3152 bcc_ptr += strlen("Linux version ");
3153 strcpy(bcc_ptr, utsname()->release);
3154 bcc_ptr += strlen(utsname()->release) + 1;
3155 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3156 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3157 bcc_ptr++; /* null domain */
3160 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3161 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3162 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3163 smb_buffer->smb_buf_length += count;
3164 pSMB->req.ByteCount = cpu_to_le16(count);
3166 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3167 &bytes_returned, CIFS_LONG_OP);
3169 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3170 } else if ((smb_buffer_response->WordCount == 3) ||
3171 (smb_buffer_response->WordCount == 4)) {
3172 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3173 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3174 if (action & GUEST_LOGIN)
3175 cFYI(1, (" Guest login")); /* BB Should we set anything
3176 in SesInfo struct ? */
3177 /* if (SecurityBlob2->MessageType != NtLm??) {
3178 cFYI("Unexpected message type on auth response is %d"));
3183 ("Check challenge UID %d vs auth response UID %d",
3184 ses->Suid, smb_buffer_response->Uid));
3185 /* UID left in wire format */
3186 ses->Suid = smb_buffer_response->Uid;
3187 bcc_ptr = pByteArea(smb_buffer_response);
3188 /* response can have either 3 or 4 word count - Samba sends 3 */
3189 if ((pSMBr->resp.hdr.WordCount == 3)
3190 || ((pSMBr->resp.hdr.WordCount == 4)
3192 pSMBr->resp.ByteCount))) {
3193 if (pSMBr->resp.hdr.WordCount == 4) {
3197 ("Security Blob Length %d ",
3202 ("NTLMSSP response to Authenticate "));
3204 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3205 if ((long) (bcc_ptr) % 2) {
3207 (BCC(smb_buffer_response)
3209 bcc_ptr++; /* Unicode strings must be word aligned */
3211 remaining_words = BCC(smb_buffer_response) / 2;
3213 len = UniStrnlen((wchar_t *) bcc_ptr,
3214 remaining_words - 1);
3215 /* We look for obvious messed up bcc or strings in response so we do not go off
3216 the end since (at least) WIN2K and Windows XP have a major bug in not null
3217 terminating last Unicode string in response */
3219 kfree(ses->serverOS);
3221 kzalloc(2 * (len + 1), GFP_KERNEL);
3222 cifs_strfromUCS_le(ses->serverOS,
3226 bcc_ptr += 2 * (len + 1);
3227 remaining_words -= len + 1;
3228 ses->serverOS[2 * len] = 0;
3229 ses->serverOS[1 + (2 * len)] = 0;
3230 if (remaining_words > 0) {
3231 len = UniStrnlen((wchar_t *)
3235 kfree(ses->serverNOS);
3237 kzalloc(2 * (len + 1),
3239 cifs_strfromUCS_le(ses->
3245 bcc_ptr += 2 * (len + 1);
3246 ses->serverNOS[2 * len] = 0;
3247 ses->serverNOS[1+(2*len)] = 0;
3248 remaining_words -= len + 1;
3249 if (remaining_words > 0) {
3250 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3251 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3252 if (ses->serverDomain)
3253 kfree(ses->serverDomain);
3278 } /* else no more room so create dummy domain string */
3280 if (ses->serverDomain)
3281 kfree(ses->serverDomain);
3282 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3284 } else { /* no room so create dummy domain and NOS string */
3285 if (ses->serverDomain)
3286 kfree(ses->serverDomain);
3287 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3288 kfree(ses->serverNOS);
3289 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3291 } else { /* ASCII */
3292 len = strnlen(bcc_ptr, 1024);
3293 if (((long) bcc_ptr + len) -
3294 (long) pByteArea(smb_buffer_response)
3295 <= BCC(smb_buffer_response)) {
3297 kfree(ses->serverOS);
3298 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3299 strncpy(ses->serverOS,bcc_ptr, len);
3302 bcc_ptr[0] = 0; /* null terminate the string */
3305 len = strnlen(bcc_ptr, 1024);
3306 kfree(ses->serverNOS);
3307 ses->serverNOS = kzalloc(len+1,
3309 strncpy(ses->serverNOS,
3315 len = strnlen(bcc_ptr, 1024);
3316 if (ses->serverDomain)
3317 kfree(ses->serverDomain);
3321 strncpy(ses->serverDomain,
3327 cFYI(1, ("field of length %d "
3328 "extends beyond end of smb ",
3332 cERROR(1, ("Security Blob extends beyond end "
3336 cERROR(1, ("No session structure passed in."));
3339 cERROR(1, ("Invalid Word count %d: ",
3340 smb_buffer_response->WordCount));
3344 cifs_buf_release(smb_buffer);
3350 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3351 const char *tree, struct cifsTconInfo *tcon,
3352 const struct nls_table *nls_codepage)
3354 struct smb_hdr *smb_buffer;
3355 struct smb_hdr *smb_buffer_response;
3358 unsigned char *bcc_ptr;
3366 smb_buffer = cifs_buf_get();
3367 if (smb_buffer == NULL) {
3370 smb_buffer_response = smb_buffer;
3372 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3373 NULL /*no tid */ , 4 /*wct */ );
3375 smb_buffer->Mid = GetNextMid(ses->server);
3376 smb_buffer->Uid = ses->Suid;
3377 pSMB = (TCONX_REQ *) smb_buffer;
3378 pSMBr = (TCONX_RSP *) smb_buffer_response;
3380 pSMB->AndXCommand = 0xFF;
3381 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3382 bcc_ptr = &pSMB->Password[0];
3383 if ((ses->server->secMode) & SECMODE_USER) {
3384 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3385 *bcc_ptr = 0; /* password is null byte */
3386 bcc_ptr++; /* skip password */
3387 /* already aligned so no need to do it below */
3389 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3390 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3391 specified as required (when that support is added to
3392 the vfs in the future) as only NTLM or the much
3393 weaker LANMAN (which we do not send by default) is accepted
3394 by Samba (not sure whether other servers allow
3395 NTLMv2 password here) */
3396 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3397 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3398 (ses->server->secType == LANMAN))
3399 calc_lanman_hash(ses, bcc_ptr);
3401 #endif /* CIFS_WEAK_PW_HASH */
3402 SMBNTencrypt(ses->password,
3403 ses->server->cryptKey,
3406 bcc_ptr += CIFS_SESS_KEY_SIZE;
3407 if (ses->capabilities & CAP_UNICODE) {
3408 /* must align unicode strings */
3409 *bcc_ptr = 0; /* null byte password */
3414 if (ses->server->secMode &
3415 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3416 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3418 if (ses->capabilities & CAP_STATUS32) {
3419 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3421 if (ses->capabilities & CAP_DFS) {
3422 smb_buffer->Flags2 |= SMBFLG2_DFS;
3424 if (ses->capabilities & CAP_UNICODE) {
3425 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3427 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3428 6 /* max utf8 char length in bytes */ *
3429 (/* server len*/ + 256 /* share len */), nls_codepage);
3430 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3431 bcc_ptr += 2; /* skip trailing null */
3432 } else { /* ASCII */
3433 strcpy(bcc_ptr, tree);
3434 bcc_ptr += strlen(tree) + 1;
3436 strcpy(bcc_ptr, "?????");
3437 bcc_ptr += strlen("?????");
3439 count = bcc_ptr - &pSMB->Password[0];
3440 pSMB->hdr.smb_buf_length += count;
3441 pSMB->ByteCount = cpu_to_le16(count);
3443 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3446 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3447 /* above now done in SendReceive */
3448 if ((rc == 0) && (tcon != NULL)) {
3449 tcon->tidStatus = CifsGood;
3450 tcon->tid = smb_buffer_response->Tid;
3451 bcc_ptr = pByteArea(smb_buffer_response);
3452 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3453 /* skip service field (NB: this field is always ASCII) */
3455 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3456 (bcc_ptr[2] == 'C')) {
3457 cFYI(1, ("IPC connection"));
3460 } else if (length == 2) {
3461 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3462 /* the most common case */
3463 cFYI(1, ("disk share connection"));
3466 bcc_ptr += length + 1;
3467 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3468 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3469 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3470 if ((bcc_ptr + (2 * length)) -
3471 pByteArea(smb_buffer_response) <=
3472 BCC(smb_buffer_response)) {
3473 kfree(tcon->nativeFileSystem);
3474 tcon->nativeFileSystem =
3475 kzalloc(length + 2, GFP_KERNEL);
3476 if (tcon->nativeFileSystem)
3478 tcon->nativeFileSystem,
3480 length, nls_codepage);
3481 bcc_ptr += 2 * length;
3482 bcc_ptr[0] = 0; /* null terminate the string */
3486 /* else do not bother copying these information fields*/
3488 length = strnlen(bcc_ptr, 1024);
3489 if ((bcc_ptr + length) -
3490 pByteArea(smb_buffer_response) <=
3491 BCC(smb_buffer_response)) {
3492 kfree(tcon->nativeFileSystem);
3493 tcon->nativeFileSystem =
3494 kzalloc(length + 1, GFP_KERNEL);
3495 if (tcon->nativeFileSystem)
3496 strncpy(tcon->nativeFileSystem, bcc_ptr,
3499 /* else do not bother copying these information fields*/
3501 if ((smb_buffer_response->WordCount == 3) ||
3502 (smb_buffer_response->WordCount == 7))
3503 /* field is in same location */
3504 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3507 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3508 } else if ((rc == 0) && tcon == NULL) {
3509 /* all we need to save for IPC$ connection */
3510 ses->ipc_tid = smb_buffer_response->Tid;
3513 cifs_buf_release(smb_buffer);
3518 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3522 struct cifsSesInfo *ses = NULL;
3523 struct task_struct *cifsd_task;
3528 if (cifs_sb->tcon) {
3529 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3530 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3535 DeleteTconOplockQEntries(cifs_sb->tcon);
3536 tconInfoFree(cifs_sb->tcon);
3537 if ((ses) && (ses->server)) {
3538 /* save off task so we do not refer to ses later */
3539 cifsd_task = ses->server->tsk;
3540 cFYI(1, ("About to do SMBLogoff "));
3541 rc = CIFSSMBLogoff(xid, ses);
3545 } else if (rc == -ESHUTDOWN) {
3546 cFYI(1, ("Waking up socket by sending signal"));
3548 force_sig(SIGKILL, cifsd_task);
3549 kthread_stop(cifsd_task);
3552 } /* else - we have an smb session
3553 left on this socket do not kill cifsd */
3555 cFYI(1, ("No session or bad tcon"));
3558 cifs_sb->tcon = NULL;
3559 tmp = cifs_sb->prepath;
3560 cifs_sb->prepathlen = 0;
3561 cifs_sb->prepath = NULL;
3570 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3571 struct nls_table *nls_info)
3574 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3575 bool ntlmv2_flag = false;
3578 /* what if server changes its buffer size after dropping the session? */
3579 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3580 rc = CIFSSMBNegotiate(xid, pSesInfo);
3581 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3582 rc = CIFSSMBNegotiate(xid, pSesInfo);
3587 spin_lock(&GlobalMid_Lock);
3588 if (pSesInfo->server->tcpStatus != CifsExiting)
3589 pSesInfo->server->tcpStatus = CifsGood;
3592 spin_unlock(&GlobalMid_Lock);
3598 pSesInfo->flags = 0;
3599 pSesInfo->capabilities = pSesInfo->server->capabilities;
3600 if (linuxExtEnabled == 0)
3601 pSesInfo->capabilities &= (~CAP_UNIX);
3602 /* pSesInfo->sequence_number = 0;*/
3604 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3605 pSesInfo->server->secMode,
3606 pSesInfo->server->capabilities,
3607 pSesInfo->server->timeAdj));
3608 if (experimEnabled < 2)
3609 rc = CIFS_SessSetup(xid, pSesInfo,
3610 first_time, nls_info);
3611 else if (extended_security
3612 && (pSesInfo->capabilities
3613 & CAP_EXTENDED_SECURITY)
3614 && (pSesInfo->server->secType == NTLMSSP)) {
3616 } else if (extended_security
3617 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3618 && (pSesInfo->server->secType == RawNTLMSSP)) {
3619 cFYI(1, ("NTLMSSP sesssetup"));
3620 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3627 cFYI(1, ("more secure NTLM ver2 hash"));
3628 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3633 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3635 CalcNTLMv2_response(pSesInfo,
3638 cifs_calculate_ntlmv2_mac_key(
3639 pSesInfo->server->mac_signing_key,
3640 response, ntlm_session_key,*/
3642 /* BB Put dummy sig in SessSetup PDU? */
3649 SMBNTencrypt(pSesInfo->password,
3650 pSesInfo->server->cryptKey,
3654 cifs_calculate_mac_key(
3655 &pSesInfo->server->mac_signing_key,
3657 pSesInfo->password);
3659 /* for better security the weaker lanman hash not sent
3660 in AuthSessSetup so we no longer calculate it */
3662 rc = CIFSNTLMSSPAuthSessSetup(xid,
3668 } else { /* old style NTLM 0.12 session setup */
3669 SMBNTencrypt(pSesInfo->password,
3670 pSesInfo->server->cryptKey,
3674 cifs_calculate_mac_key(
3675 &pSesInfo->server->mac_signing_key,
3676 ntlm_session_key, pSesInfo->password);
3678 rc = CIFSSessSetup(xid, pSesInfo,
3679 ntlm_session_key, nls_info);
3682 cERROR(1, ("Send error in SessSetup = %d", rc));
3684 cFYI(1, ("CIFS Session Established successfully"));
3685 pSesInfo->status = CifsGood;