4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 static DECLARE_COMPLETION(cifsd_complete);
54 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
57 extern mempool_t *cifs_req_poolp;
65 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[16]; /* netbios name of client */
68 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
78 unsigned override_uid:1;
79 unsigned override_gid:1;
81 unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
83 unsigned no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 unsigned server_ino:1; /* use inode numbers from server ie UniqueId */
86 unsigned remap:1; /* set to remap seven reserved chars in filenames */
87 unsigned posix_paths:1; /* unset to not ask for posix pathnames. */
88 unsigned no_linux_ext:1;
90 unsigned nullauth:1; /* attempt to authenticate with null user */
91 unsigned nocase; /* request case insensitive filenames */
92 unsigned nobrl; /* disable sending byte range locks to srv */
96 unsigned short int port;
100 static int ipv4_connect(struct sockaddr_in *psin_server,
101 struct socket **csocket,
103 char *server_netb_name);
104 static int ipv6_connect(struct sockaddr_in6 *psin_server,
105 struct socket **csocket);
109 * cifs tcp session reconnection
111 * mark tcp session as reconnecting so temporarily locked
112 * mark all smb sessions as reconnecting for tcp session
113 * reconnect tcp session
114 * wake up waiters on reconnection? - (not needed currently)
118 cifs_reconnect(struct TCP_Server_Info *server)
121 struct list_head *tmp;
122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
124 struct mid_q_entry *mid_entry;
126 spin_lock(&GlobalMid_Lock);
127 if (kthread_should_stop()) {
128 /* the demux thread will exit normally
129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
137 cFYI(1, ("Reconnecting tcp session"));
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
141 read_lock(&GlobalSMBSeslock);
142 list_for_each(tmp, &GlobalSMBSessionList) {
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
145 if (ses->server == server) {
146 ses->status = CifsNeedReconnect;
150 /* else tcp and smb sessions need reconnection */
152 list_for_each(tmp, &GlobalTreeConnectionList) {
153 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
154 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
155 tcon->tidStatus = CifsNeedReconnect;
157 read_unlock(&GlobalSMBSeslock);
158 /* do not want to be sending data on a socket we are freeing */
159 down(&server->tcpSem);
160 if (server->ssocket) {
161 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
162 server->ssocket->flags));
163 kernel_sock_shutdown(server->ssocket, SHUT_WR);
164 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
165 server->ssocket->state,
166 server->ssocket->flags));
167 sock_release(server->ssocket);
168 server->ssocket = NULL;
171 spin_lock(&GlobalMid_Lock);
172 list_for_each(tmp, &server->pending_mid_q) {
173 mid_entry = list_entry(tmp, struct
177 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
178 /* Mark other intransit requests as needing
179 retry so we do not immediately mark the
180 session bad again (ie after we reconnect
181 below) as they timeout too */
182 mid_entry->midState = MID_RETRY_NEEDED;
186 spin_unlock(&GlobalMid_Lock);
189 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
191 if (server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,
195 rc = ipv4_connect(&server->addr.sockAddr,
197 server->workstation_RFC1001_name,
198 server->server_RFC1001_name);
201 cFYI(1, ("reconnect error %d", rc));
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
206 if (!kthread_should_stop())
207 server->tcpStatus = CifsGood;
208 server->sequence_number = 0;
209 spin_unlock(&GlobalMid_Lock);
210 /* atomic_set(&server->inFlight,0);*/
211 wake_up(&server->response_q);
219 0 not a transact2, or all data present
220 >0 transact2 with that much data missing
221 -EINVAL = invalid transact2
224 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
226 struct smb_t2_rsp *pSMBt;
228 int data_in_this_rsp;
231 if (pSMB->Command != SMB_COM_TRANSACTION2)
234 /* check for plausible wct, bcc and t2 data and parm sizes */
235 /* check for parm and data offset going beyond end of smb */
236 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
237 cFYI(1, ("invalid transact2 word count"));
241 pSMBt = (struct smb_t2_rsp *)pSMB;
243 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
244 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
246 remaining = total_data_size - data_in_this_rsp;
250 else if (remaining < 0) {
251 cFYI(1, ("total data %d smaller than data in frame %d",
252 total_data_size, data_in_this_rsp));
255 cFYI(1, ("missing %d bytes from transact2, check next response",
257 if (total_data_size > maxBufSize) {
258 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
259 total_data_size, maxBufSize));
266 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
268 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
269 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
274 char *data_area_of_target;
275 char *data_area_of_buf2;
278 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
280 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
281 cFYI(1, ("total data size of primary and secondary t2 differ"));
284 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
286 remaining = total_data_size - total_in_buf;
291 if (remaining == 0) /* nothing to do, ignore */
294 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
295 if (remaining < total_in_buf2) {
296 cFYI(1, ("transact2 2nd response contains too much data"));
299 /* find end of first SMB data area */
300 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
301 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
302 /* validate target area */
304 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
305 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
307 data_area_of_target += total_in_buf;
309 /* copy second buffer into end of first buffer */
310 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
311 total_in_buf += total_in_buf2;
312 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
313 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
314 byte_count += total_in_buf2;
315 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
317 byte_count = pTargetSMB->smb_buf_length;
318 byte_count += total_in_buf2;
320 /* BB also add check that we are not beyond maximum buffer size */
322 pTargetSMB->smb_buf_length = byte_count;
324 if (remaining == total_in_buf2) {
325 cFYI(1, ("found the last secondary response"));
326 return 0; /* we are done */
327 } else /* more responses to go */
333 cifs_demultiplex_thread(struct TCP_Server_Info *server)
336 unsigned int pdu_length, total_read;
337 struct smb_hdr *smb_buffer = NULL;
338 struct smb_hdr *bigbuf = NULL;
339 struct smb_hdr *smallbuf = NULL;
340 struct msghdr smb_msg;
342 struct socket *csocket = server->ssocket;
343 struct list_head *tmp;
344 struct cifsSesInfo *ses;
345 struct task_struct *task_to_wake = NULL;
346 struct mid_q_entry *mid_entry;
348 int isLargeBuf = FALSE;
352 current->flags |= PF_MEMALLOC;
353 server->tsk = current; /* save process info to wake at shutdown */
354 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
355 write_lock(&GlobalSMBSeslock);
356 atomic_inc(&tcpSesAllocCount);
357 length = tcpSesAllocCount.counter;
358 write_unlock(&GlobalSMBSeslock);
359 complete(&cifsd_complete);
361 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
365 while (!kthread_should_stop()) {
368 if (bigbuf == NULL) {
369 bigbuf = cifs_buf_get();
371 cERROR(1, ("No memory for large SMB response"));
373 /* retry will check if exiting */
376 } else if (isLargeBuf) {
377 /* we are reusing a dirty large buf, clear its start */
378 memset(bigbuf, 0, sizeof(struct smb_hdr));
381 if (smallbuf == NULL) {
382 smallbuf = cifs_small_buf_get();
384 cERROR(1, ("No memory for SMB response"));
386 /* retry will check if exiting */
389 /* beginning of smb buffer is cleared in our buf_get */
390 } else /* if existing small buf clear beginning */
391 memset(smallbuf, 0, sizeof(struct smb_hdr));
395 smb_buffer = smallbuf;
396 iov.iov_base = smb_buffer;
398 smb_msg.msg_control = NULL;
399 smb_msg.msg_controllen = 0;
400 pdu_length = 4; /* enough to get RFC1001 header */
403 kernel_recvmsg(csocket, &smb_msg,
404 &iov, 1, pdu_length, 0 /* BB other flags? */);
406 if (kthread_should_stop()) {
408 } else if (server->tcpStatus == CifsNeedReconnect) {
409 cFYI(1, ("Reconnect after server stopped responding"));
410 cifs_reconnect(server);
411 cFYI(1, ("call to reconnect done"));
412 csocket = server->ssocket;
414 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
415 msleep(1); /* minimum sleep to prevent looping
416 allowing socket to clear and app threads to set
417 tcpStatus CifsNeedReconnect if server hung */
422 } else if (length <= 0) {
423 if (server->tcpStatus == CifsNew) {
424 cFYI(1, ("tcp session abend after SMBnegprot"));
425 /* some servers kill the TCP session rather than
426 returning an SMB negprot error, in which
427 case reconnecting here is not going to help,
428 and so simply return error to mount */
431 if (!try_to_freeze() && (length == -EINTR)) {
432 cFYI(1, ("cifsd thread killed"));
435 cFYI(1, ("Reconnect after unexpected peek error %d",
437 cifs_reconnect(server);
438 csocket = server->ssocket;
439 wake_up(&server->response_q);
441 } else if (length < pdu_length) {
442 cFYI(1, ("requested %d bytes but only got %d bytes",
443 pdu_length, length));
444 pdu_length -= length;
449 /* The right amount was read from socket - 4 bytes */
450 /* so we can now interpret the length field */
452 /* the first byte big endian of the length field,
453 is actually not part of the length but the type
454 with the most common, zero, as regular data */
455 temp = *((char *) smb_buffer);
457 /* Note that FC 1001 length is big endian on the wire,
458 but we convert it here so it is always manipulated
459 as host byte order */
460 pdu_length = ntohl(smb_buffer->smb_buf_length);
461 smb_buffer->smb_buf_length = pdu_length;
463 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
465 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
467 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
468 cFYI(1, ("Good RFC 1002 session rsp"));
470 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
471 /* we get this from Windows 98 instead of
472 an error on SMB negprot response */
473 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
475 if (server->tcpStatus == CifsNew) {
476 /* if nack on negprot (rather than
477 ret of smb negprot error) reconnecting
478 not going to help, ret error to mount */
481 /* give server a second to
482 clean up before reconnect attempt */
484 /* always try 445 first on reconnect
485 since we get NACK on some if we ever
486 connected to port 139 (the NACK is
487 since we do not begin with RFC1001
488 session initialize frame) */
489 server->addr.sockAddr.sin_port =
491 cifs_reconnect(server);
492 csocket = server->ssocket;
493 wake_up(&server->response_q);
496 } else if (temp != (char) 0) {
497 cERROR(1, ("Unknown RFC 1002 frame"));
498 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
500 cifs_reconnect(server);
501 csocket = server->ssocket;
505 /* else we have an SMB response */
506 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
507 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
508 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
509 length, pdu_length+4));
510 cifs_reconnect(server);
511 csocket = server->ssocket;
512 wake_up(&server->response_q);
519 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
521 memcpy(bigbuf, smallbuf, 4);
525 iov.iov_base = 4 + (char *)smb_buffer;
526 iov.iov_len = pdu_length;
527 for (total_read = 0; total_read < pdu_length;
528 total_read += length) {
529 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
530 pdu_length - total_read, 0);
531 if (kthread_should_stop() ||
532 (length == -EINTR)) {
536 } else if (server->tcpStatus == CifsNeedReconnect) {
537 cifs_reconnect(server);
538 csocket = server->ssocket;
539 /* Reconnect wakes up rspns q */
540 /* Now we will reread sock */
543 } else if ((length == -ERESTARTSYS) ||
544 (length == -EAGAIN)) {
545 msleep(1); /* minimum sleep to prevent looping,
546 allowing socket to clear and app
547 threads to set tcpStatus
548 CifsNeedReconnect if server hung*/
551 } else if (length <= 0) {
552 cERROR(1, ("Received no data, expecting %d",
553 pdu_length - total_read));
554 cifs_reconnect(server);
555 csocket = server->ssocket;
562 else if (reconnect == 1)
565 length += 4; /* account for rfc1002 hdr */
568 dump_smb(smb_buffer, length);
569 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
570 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
576 spin_lock(&GlobalMid_Lock);
577 list_for_each(tmp, &server->pending_mid_q) {
578 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
580 if ((mid_entry->mid == smb_buffer->Mid) &&
581 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
582 (mid_entry->command == smb_buffer->Command)) {
583 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
584 /* We have a multipart transact2 resp */
586 if (mid_entry->resp_buf) {
587 /* merge response - fix up 1st*/
588 if (coalesce_t2(smb_buffer,
589 mid_entry->resp_buf)) {
590 mid_entry->multiRsp = 1;
593 /* all parts received */
594 mid_entry->multiEnd = 1;
599 cERROR(1,("1st trans2 resp needs bigbuf"));
600 /* BB maybe we can fix this up, switch
601 to already allocated large buffer? */
603 /* Have first buffer */
604 mid_entry->resp_buf =
606 mid_entry->largeBuf = 1;
612 mid_entry->resp_buf = smb_buffer;
614 mid_entry->largeBuf = 1;
616 mid_entry->largeBuf = 0;
618 task_to_wake = mid_entry->tsk;
619 mid_entry->midState = MID_RESPONSE_RECEIVED;
620 #ifdef CONFIG_CIFS_STATS2
621 mid_entry->when_received = jiffies;
623 /* so we do not time out requests to server
624 which is still responding (since server could
625 be busy but not dead) */
626 server->lstrp = jiffies;
630 spin_unlock(&GlobalMid_Lock);
632 /* Was previous buf put in mpx struct for multi-rsp? */
634 /* smb buffer will be freed by user thread */
640 wake_up_process(task_to_wake);
641 } else if ((is_valid_oplock_break(smb_buffer, server) == FALSE)
642 && (isMultiRsp == FALSE)) {
643 cERROR(1, ("No task to wake, unknown frame received! "
644 "NumMids %d", midCount.counter));
645 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
646 sizeof(struct smb_hdr));
647 #ifdef CONFIG_CIFS_DEBUG2
648 cifs_dump_detail(smb_buffer);
649 cifs_dump_mids(server);
650 #endif /* CIFS_DEBUG2 */
653 } /* end while !EXITING */
655 spin_lock(&GlobalMid_Lock);
656 server->tcpStatus = CifsExiting;
658 /* check if we have blocked requests that need to free */
659 /* Note that cifs_max_pending is normally 50, but
660 can be set at module install time to as little as two */
661 if (atomic_read(&server->inFlight) >= cifs_max_pending)
662 atomic_set(&server->inFlight, cifs_max_pending - 1);
663 /* We do not want to set the max_pending too low or we
664 could end up with the counter going negative */
665 spin_unlock(&GlobalMid_Lock);
666 /* Although there should not be any requests blocked on
667 this queue it can not hurt to be paranoid and try to wake up requests
668 that may haven been blocked when more than 50 at time were on the wire
669 to the same server - they now will see the session is in exit state
670 and get out of SendReceive. */
671 wake_up_all(&server->request_q);
672 /* give those requests time to exit */
675 if (server->ssocket) {
676 sock_release(csocket);
677 server->ssocket = NULL;
679 /* buffer usuallly freed in free_mid - need to free it here on exit */
680 cifs_buf_release(bigbuf);
681 if (smallbuf) /* no sense logging a debug message if NULL */
682 cifs_small_buf_release(smallbuf);
684 read_lock(&GlobalSMBSeslock);
685 if (list_empty(&server->pending_mid_q)) {
686 /* loop through server session structures attached to this and
688 list_for_each(tmp, &GlobalSMBSessionList) {
690 list_entry(tmp, struct cifsSesInfo,
692 if (ses->server == server) {
693 ses->status = CifsExiting;
697 read_unlock(&GlobalSMBSeslock);
699 /* although we can not zero the server struct pointer yet,
700 since there are active requests which may depnd on them,
701 mark the corresponding SMB sessions as exiting too */
702 list_for_each(tmp, &GlobalSMBSessionList) {
703 ses = list_entry(tmp, struct cifsSesInfo,
705 if (ses->server == server)
706 ses->status = CifsExiting;
709 spin_lock(&GlobalMid_Lock);
710 list_for_each(tmp, &server->pending_mid_q) {
711 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
712 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
713 cFYI(1, ("Clearing Mid 0x%x - waking up ",
715 task_to_wake = mid_entry->tsk;
717 wake_up_process(task_to_wake);
720 spin_unlock(&GlobalMid_Lock);
721 read_unlock(&GlobalSMBSeslock);
722 /* 1/8th of sec is more than enough time for them to exit */
726 if (!list_empty(&server->pending_mid_q)) {
727 /* mpx threads have not exited yet give them
728 at least the smb send timeout time for long ops */
729 /* due to delays on oplock break requests, we need
730 to wait at least 45 seconds before giving up
731 on a request getting a response and going ahead
733 cFYI(1, ("Wait for exit from demultiplex thread"));
735 /* if threads still have not exited they are probably never
736 coming home not much else we can do but free the memory */
739 write_lock(&GlobalSMBSeslock);
740 atomic_dec(&tcpSesAllocCount);
741 length = tcpSesAllocCount.counter;
743 /* last chance to mark ses pointers invalid
744 if there are any pointing to this (e.g
745 if a crazy root user tried to kill cifsd
746 kernel thread explicitly this might happen) */
747 list_for_each(tmp, &GlobalSMBSessionList) {
748 ses = list_entry(tmp, struct cifsSesInfo,
750 if (ses->server == server)
753 write_unlock(&GlobalSMBSeslock);
755 kfree(server->hostname);
758 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
764 /* extract the host portion of the UNC string */
766 extract_hostname(const char *unc)
772 /* skip double chars at beginning of string */
773 /* BB: check validity of these bytes? */
776 /* delimiter between hostname and sharename is always '\\' now */
777 delim = strchr(src, '\\');
779 return ERR_PTR(-EINVAL);
782 dst = kmalloc((len + 1), GFP_KERNEL);
784 return ERR_PTR(-ENOMEM);
786 memcpy(dst, src, len);
793 cifs_parse_mount_options(char *options, const char *devname,
798 unsigned int temp_len, i, j;
804 if (Local_System_Name[0] != 0)
805 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
807 char *nodename = utsname()->nodename;
808 int n = strnlen(nodename, 15);
809 memset(vol->source_rfc1001_name, 0x20, 15);
810 for (i = 0; i < n; i++) {
811 /* does not have to be perfect mapping since field is
812 informational, only used for servers that do not support
813 port 445 and it can be overridden at mount time */
814 vol->source_rfc1001_name[i] = toupper(nodename[i]);
817 vol->source_rfc1001_name[15] = 0;
818 /* null target name indicates to use *SMBSERVR default called name
819 if we end up sending RFC1001 session initialize */
820 vol->target_rfc1001_name[0] = 0;
821 vol->linux_uid = current->uid; /* current->euid instead? */
822 vol->linux_gid = current->gid;
823 vol->dir_mode = S_IRWXUGO;
824 /* 2767 perms indicate mandatory locking support */
825 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
827 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
829 /* default is always to request posix paths. */
830 vol->posix_paths = 1;
835 if (strncmp(options, "sep=", 4) == 0) {
836 if (options[4] != 0) {
837 separator[0] = options[4];
840 cFYI(1, ("Null separator not allowed"));
844 while ((data = strsep(&options, separator)) != NULL) {
847 if ((value = strchr(data, '=')) != NULL)
850 /* Have to parse this before we parse for "user" */
851 if (strnicmp(data, "user_xattr", 10) == 0) {
853 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
855 } else if (strnicmp(data, "user", 4) == 0) {
858 "CIFS: invalid or missing username\n");
859 return 1; /* needs_arg; */
860 } else if (!*value) {
861 /* null user, ie anonymous, authentication */
864 if (strnlen(value, 200) < 200) {
865 vol->username = value;
867 printk(KERN_WARNING "CIFS: username too long\n");
870 } else if (strnicmp(data, "pass", 4) == 0) {
872 vol->password = NULL;
874 } else if (value[0] == 0) {
875 /* check if string begins with double comma
876 since that would mean the password really
877 does start with a comma, and would not
878 indicate an empty string */
879 if (value[1] != separator[0]) {
880 vol->password = NULL;
884 temp_len = strlen(value);
885 /* removed password length check, NTLM passwords
886 can be arbitrarily long */
888 /* if comma in password, the string will be
889 prematurely null terminated. Commas in password are
890 specified across the cifs mount interface by a double
891 comma ie ,, and a comma used as in other cases ie ','
892 as a parameter delimiter/separator is single and due
893 to the strsep above is temporarily zeroed. */
895 /* NB: password legally can have multiple commas and
896 the only illegal character in a password is null */
898 if ((value[temp_len] == 0) &&
899 (value[temp_len+1] == separator[0])) {
901 value[temp_len] = separator[0];
902 temp_len += 2; /* move after second comma */
903 while (value[temp_len] != 0) {
904 if (value[temp_len] == separator[0]) {
905 if (value[temp_len+1] ==
907 /* skip second comma */
910 /* single comma indicating start
917 if (value[temp_len] == 0) {
921 /* point option to start of next parm */
922 options = value + temp_len + 1;
924 /* go from value to value + temp_len condensing
925 double commas to singles. Note that this ends up
926 allocating a few bytes too many, which is ok */
927 vol->password = kzalloc(temp_len, GFP_KERNEL);
928 if (vol->password == NULL) {
929 printk(KERN_WARNING "CIFS: no memory "
933 for (i = 0, j = 0; i < temp_len; i++, j++) {
934 vol->password[j] = value[i];
935 if (value[i] == separator[0]
936 && value[i+1] == separator[0]) {
937 /* skip second comma */
941 vol->password[j] = 0;
943 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
944 if (vol->password == NULL) {
945 printk(KERN_WARNING "CIFS: no memory "
949 strcpy(vol->password, value);
951 } else if (strnicmp(data, "ip", 2) == 0) {
952 if (!value || !*value) {
954 } else if (strnlen(value, 35) < 35) {
957 printk(KERN_WARNING "CIFS: ip address "
961 } else if (strnicmp(data, "sec", 3) == 0) {
962 if (!value || !*value) {
963 cERROR(1, ("no security value specified"));
965 } else if (strnicmp(value, "krb5i", 5) == 0) {
966 vol->secFlg |= CIFSSEC_MAY_KRB5 |
968 } else if (strnicmp(value, "krb5p", 5) == 0) {
969 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
971 cERROR(1, ("Krb5 cifs privacy not supported"));
973 } else if (strnicmp(value, "krb5", 4) == 0) {
974 vol->secFlg |= CIFSSEC_MAY_KRB5;
975 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
976 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
978 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
979 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
980 } else if (strnicmp(value, "ntlmi", 5) == 0) {
981 vol->secFlg |= CIFSSEC_MAY_NTLM |
983 } else if (strnicmp(value, "ntlm", 4) == 0) {
984 /* ntlm is default so can be turned off too */
985 vol->secFlg |= CIFSSEC_MAY_NTLM;
986 } else if (strnicmp(value, "nontlm", 6) == 0) {
987 /* BB is there a better way to do this? */
988 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
989 #ifdef CONFIG_CIFS_WEAK_PW_HASH
990 } else if (strnicmp(value, "lanman", 6) == 0) {
991 vol->secFlg |= CIFSSEC_MAY_LANMAN;
993 } else if (strnicmp(value, "none", 4) == 0) {
996 cERROR(1, ("bad security option: %s", value));
999 } else if ((strnicmp(data, "unc", 3) == 0)
1000 || (strnicmp(data, "target", 6) == 0)
1001 || (strnicmp(data, "path", 4) == 0)) {
1002 if (!value || !*value) {
1003 printk(KERN_WARNING "CIFS: invalid path to "
1004 "network resource\n");
1005 return 1; /* needs_arg; */
1007 if ((temp_len = strnlen(value, 300)) < 300) {
1008 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1009 if (vol->UNC == NULL)
1011 strcpy(vol->UNC, value);
1012 if (strncmp(vol->UNC, "//", 2) == 0) {
1015 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1017 "CIFS: UNC Path does not begin "
1018 "with // or \\\\ \n");
1022 printk(KERN_WARNING "CIFS: UNC name too long\n");
1025 } else if ((strnicmp(data, "domain", 3) == 0)
1026 || (strnicmp(data, "workgroup", 5) == 0)) {
1027 if (!value || !*value) {
1028 printk(KERN_WARNING "CIFS: invalid domain name\n");
1029 return 1; /* needs_arg; */
1031 /* BB are there cases in which a comma can be valid in
1032 a domain name and need special handling? */
1033 if (strnlen(value, 256) < 256) {
1034 vol->domainname = value;
1035 cFYI(1, ("Domain name set"));
1037 printk(KERN_WARNING "CIFS: domain name too "
1041 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1042 if (!value || !*value) {
1044 "CIFS: invalid path prefix\n");
1045 return 1; /* needs_argument */
1047 if ((temp_len = strnlen(value, 1024)) < 1024) {
1048 if (value[0] != '/')
1049 temp_len++; /* missing leading slash */
1050 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1051 if (vol->prepath == NULL)
1053 if (value[0] != '/') {
1054 vol->prepath[0] = '/';
1055 strcpy(vol->prepath+1, value);
1057 strcpy(vol->prepath, value);
1058 cFYI(1, ("prefix path %s", vol->prepath));
1060 printk(KERN_WARNING "CIFS: prefix too long\n");
1063 } else if (strnicmp(data, "iocharset", 9) == 0) {
1064 if (!value || !*value) {
1065 printk(KERN_WARNING "CIFS: invalid iocharset "
1067 return 1; /* needs_arg; */
1069 if (strnlen(value, 65) < 65) {
1070 if (strnicmp(value, "default", 7))
1071 vol->iocharset = value;
1072 /* if iocharset not set then load_nls_default
1073 is used by caller */
1074 cFYI(1, ("iocharset set to %s", value));
1076 printk(KERN_WARNING "CIFS: iocharset name "
1080 } else if (strnicmp(data, "uid", 3) == 0) {
1081 if (value && *value) {
1083 simple_strtoul(value, &value, 0);
1084 vol->override_uid = 1;
1086 } else if (strnicmp(data, "gid", 3) == 0) {
1087 if (value && *value) {
1089 simple_strtoul(value, &value, 0);
1090 vol->override_gid = 1;
1092 } else if (strnicmp(data, "file_mode", 4) == 0) {
1093 if (value && *value) {
1095 simple_strtoul(value, &value, 0);
1097 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1098 if (value && *value) {
1100 simple_strtoul(value, &value, 0);
1102 } else if (strnicmp(data, "dirmode", 4) == 0) {
1103 if (value && *value) {
1105 simple_strtoul(value, &value, 0);
1107 } else if (strnicmp(data, "port", 4) == 0) {
1108 if (value && *value) {
1110 simple_strtoul(value, &value, 0);
1112 } else if (strnicmp(data, "rsize", 5) == 0) {
1113 if (value && *value) {
1115 simple_strtoul(value, &value, 0);
1117 } else if (strnicmp(data, "wsize", 5) == 0) {
1118 if (value && *value) {
1120 simple_strtoul(value, &value, 0);
1122 } else if (strnicmp(data, "sockopt", 5) == 0) {
1123 if (value && *value) {
1125 simple_strtoul(value, &value, 0);
1127 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1128 if (!value || !*value || (*value == ' ')) {
1129 cFYI(1, ("invalid (empty) netbiosname"));
1131 memset(vol->source_rfc1001_name, 0x20, 15);
1132 for (i = 0; i < 15; i++) {
1133 /* BB are there cases in which a comma can be
1134 valid in this workstation netbios name (and need
1135 special handling)? */
1137 /* We do not uppercase netbiosname for user */
1141 vol->source_rfc1001_name[i] =
1144 /* The string has 16th byte zero still from
1145 set at top of the function */
1146 if ((i == 15) && (value[i] != 0))
1147 printk(KERN_WARNING "CIFS: netbiosname"
1148 " longer than 15 truncated.\n");
1150 } else if (strnicmp(data, "servern", 7) == 0) {
1151 /* servernetbiosname specified override *SMBSERVER */
1152 if (!value || !*value || (*value == ' ')) {
1153 cFYI(1, ("empty server netbiosname specified"));
1155 /* last byte, type, is 0x20 for servr type */
1156 memset(vol->target_rfc1001_name, 0x20, 16);
1158 for (i = 0; i < 15; i++) {
1159 /* BB are there cases in which a comma can be
1160 valid in this workstation netbios name
1161 (and need special handling)? */
1163 /* user or mount helper must uppercase
1168 vol->target_rfc1001_name[i] =
1171 /* The string has 16th byte zero still from
1172 set at top of the function */
1173 if ((i == 15) && (value[i] != 0))
1174 printk(KERN_WARNING "CIFS: server net"
1175 "biosname longer than 15 truncated.\n");
1177 } else if (strnicmp(data, "credentials", 4) == 0) {
1179 } else if (strnicmp(data, "version", 3) == 0) {
1181 } else if (strnicmp(data, "guest", 5) == 0) {
1183 } else if (strnicmp(data, "rw", 2) == 0) {
1185 } else if ((strnicmp(data, "suid", 4) == 0) ||
1186 (strnicmp(data, "nosuid", 6) == 0) ||
1187 (strnicmp(data, "exec", 4) == 0) ||
1188 (strnicmp(data, "noexec", 6) == 0) ||
1189 (strnicmp(data, "nodev", 5) == 0) ||
1190 (strnicmp(data, "noauto", 6) == 0) ||
1191 (strnicmp(data, "dev", 3) == 0)) {
1192 /* The mount tool or mount.cifs helper (if present)
1193 uses these opts to set flags, and the flags are read
1194 by the kernel vfs layer before we get here (ie
1195 before read super) so there is no point trying to
1196 parse these options again and set anything and it
1197 is ok to just ignore them */
1199 } else if (strnicmp(data, "ro", 2) == 0) {
1201 } else if (strnicmp(data, "hard", 4) == 0) {
1203 } else if (strnicmp(data, "soft", 4) == 0) {
1205 } else if (strnicmp(data, "perm", 4) == 0) {
1207 } else if (strnicmp(data, "noperm", 6) == 0) {
1209 } else if (strnicmp(data, "mapchars", 8) == 0) {
1211 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1213 } else if (strnicmp(data, "sfu", 3) == 0) {
1215 } else if (strnicmp(data, "nosfu", 5) == 0) {
1217 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1218 vol->posix_paths = 1;
1219 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1220 vol->posix_paths = 0;
1221 } else if (strnicmp(data, "nounix", 6) == 0) {
1222 vol->no_linux_ext = 1;
1223 } else if (strnicmp(data, "nolinux", 7) == 0) {
1224 vol->no_linux_ext = 1;
1225 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1226 (strnicmp(data, "ignorecase", 10) == 0)) {
1228 } else if (strnicmp(data, "brl", 3) == 0) {
1230 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1231 (strnicmp(data, "nolock", 6) == 0)) {
1233 /* turn off mandatory locking in mode
1234 if remote locking is turned off since the
1235 local vfs will do advisory */
1236 if (vol->file_mode ==
1237 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1238 vol->file_mode = S_IALLUGO;
1239 } else if (strnicmp(data, "setuids", 7) == 0) {
1241 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1243 } else if (strnicmp(data, "nohard", 6) == 0) {
1245 } else if (strnicmp(data, "nosoft", 6) == 0) {
1247 } else if (strnicmp(data, "nointr", 6) == 0) {
1249 } else if (strnicmp(data, "intr", 4) == 0) {
1251 } else if (strnicmp(data, "serverino", 7) == 0) {
1252 vol->server_ino = 1;
1253 } else if (strnicmp(data, "noserverino", 9) == 0) {
1254 vol->server_ino = 0;
1255 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1257 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1259 } else if (strnicmp(data, "acl", 3) == 0) {
1260 vol->no_psx_acl = 0;
1261 } else if (strnicmp(data, "noacl", 5) == 0) {
1262 vol->no_psx_acl = 1;
1263 } else if (strnicmp(data, "sign", 4) == 0) {
1264 vol->secFlg |= CIFSSEC_MUST_SIGN;
1265 /* } else if (strnicmp(data, "seal",4) == 0) {
1266 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1267 } else if (strnicmp(data, "direct", 6) == 0) {
1269 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1271 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1272 if (!value || !*value) {
1273 vol->in6_addr = NULL;
1274 } else if (strnlen(value, 49) == 48) {
1275 vol->in6_addr = value;
1277 printk(KERN_WARNING "CIFS: ip v6 address not "
1278 "48 characters long\n");
1281 } else if (strnicmp(data, "noac", 4) == 0) {
1282 printk(KERN_WARNING "CIFS: Mount option noac not "
1283 "supported. Instead set "
1284 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1286 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1289 if (vol->UNC == NULL) {
1290 if (devname == NULL) {
1291 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1295 if ((temp_len = strnlen(devname, 300)) < 300) {
1296 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1297 if (vol->UNC == NULL)
1299 strcpy(vol->UNC, devname);
1300 if (strncmp(vol->UNC, "//", 2) == 0) {
1303 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1304 printk(KERN_WARNING "CIFS: UNC Path does not "
1305 "begin with // or \\\\ \n");
1309 printk(KERN_WARNING "CIFS: UNC name too long\n");
1313 if (vol->UNCip == NULL)
1314 vol->UNCip = &vol->UNC[2];
1319 static struct cifsSesInfo *
1320 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1321 struct in6_addr *target_ip6_addr,
1322 char *userName, struct TCP_Server_Info **psrvTcp)
1324 struct list_head *tmp;
1325 struct cifsSesInfo *ses;
1327 read_lock(&GlobalSMBSeslock);
1329 list_for_each(tmp, &GlobalSMBSessionList) {
1330 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1332 if ((target_ip_addr &&
1333 (ses->server->addr.sockAddr.sin_addr.s_addr
1334 == target_ip_addr->s_addr)) || (target_ip6_addr
1335 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1336 target_ip6_addr, sizeof(*target_ip6_addr)))) {
1337 /* BB lock server and tcp session and increment
1340 /* found a match on the TCP session */
1341 *psrvTcp = ses->server;
1343 /* BB check if reconnection needed */
1345 (ses->userName, userName,
1346 MAX_USERNAME_SIZE) == 0){
1347 read_unlock(&GlobalSMBSeslock);
1348 /* Found exact match on both TCP and
1354 /* else tcp and smb sessions need reconnection */
1356 read_unlock(&GlobalSMBSeslock);
1360 static struct cifsTconInfo *
1361 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1363 struct list_head *tmp;
1364 struct cifsTconInfo *tcon;
1366 read_lock(&GlobalSMBSeslock);
1367 list_for_each(tmp, &GlobalTreeConnectionList) {
1368 cFYI(1, ("Next tcon"));
1369 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1371 if (tcon->ses->server) {
1373 ("old ip addr: %x == new ip %x ?",
1374 tcon->ses->server->addr.sockAddr.sin_addr.
1375 s_addr, new_target_ip_addr));
1376 if (tcon->ses->server->addr.sockAddr.sin_addr.
1377 s_addr == new_target_ip_addr) {
1378 /* BB lock tcon, server and tcp session and increment use count here? */
1379 /* found a match on the TCP session */
1380 /* BB check if reconnection needed */
1382 ("IP match, old UNC: %s new: %s",
1383 tcon->treeName, uncName));
1385 (tcon->treeName, uncName,
1386 MAX_TREE_SIZE) == 0) {
1388 ("and old usr: %s new: %s",
1389 tcon->treeName, uncName));
1391 (tcon->ses->userName,
1393 MAX_USERNAME_SIZE) == 0) {
1394 read_unlock(&GlobalSMBSeslock);
1395 /* matched smb session
1404 read_unlock(&GlobalSMBSeslock);
1409 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1410 const char *old_path, const struct nls_table *nls_codepage,
1413 struct dfs_info3_param *referrals = NULL;
1414 unsigned int num_referrals;
1417 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
1418 &num_referrals, &referrals, remap);
1420 /* BB Add in code to: if valid refrl, if not ip address contact
1421 the helper that resolves tcp names, mount to it, try to
1422 tcon to it unmount it if fail */
1430 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1431 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1432 struct dfs_info3_param **preferrals, int remap)
1436 unsigned char *targetUNCs;
1438 *pnum_referrals = 0;
1441 if (pSesInfo->ipc_tid == 0) {
1442 temp_unc = kmalloc(2 /* for slashes */ +
1443 strnlen(pSesInfo->serverName,
1444 SERVER_NAME_LEN_WITH_NULL * 2)
1445 + 1 + 4 /* slash IPC$ */ + 2,
1447 if (temp_unc == NULL)
1451 strcpy(temp_unc + 2, pSesInfo->serverName);
1452 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1453 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1455 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1459 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
1460 pnum_referrals, nls_codepage, remap);
1461 /* BB map targetUNCs to dfs_info3 structures, here or
1462 in CIFSGetDFSRefer BB */
1467 /* See RFC1001 section 14 on representation of Netbios names */
1468 static void rfc1002mangle(char *target, char *source, unsigned int length)
1472 for (i = 0, j = 0; i < (length); i++) {
1473 /* mask a nibble at a time and encode */
1474 target[j] = 'A' + (0x0F & (source[i] >> 4));
1475 target[j+1] = 'A' + (0x0F & source[i]);
1483 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1484 char *netbios_name, char *target_name)
1488 __be16 orig_port = 0;
1490 if (*csocket == NULL) {
1491 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1492 IPPROTO_TCP, csocket);
1494 cERROR(1, ("Error %d creating socket", rc));
1498 /* BB other socket options to set KEEPALIVE, NODELAY? */
1499 cFYI(1, ("Socket created"));
1500 (*csocket)->sk->sk_allocation = GFP_NOFS;
1504 psin_server->sin_family = AF_INET;
1505 if (psin_server->sin_port) { /* user overrode default port */
1506 rc = (*csocket)->ops->connect(*csocket,
1507 (struct sockaddr *) psin_server,
1508 sizeof(struct sockaddr_in), 0);
1514 /* save original port so we can retry user specified port
1515 later if fall back ports fail this time */
1516 orig_port = psin_server->sin_port;
1518 /* do not retry on the same port we just failed on */
1519 if (psin_server->sin_port != htons(CIFS_PORT)) {
1520 psin_server->sin_port = htons(CIFS_PORT);
1522 rc = (*csocket)->ops->connect(*csocket,
1523 (struct sockaddr *) psin_server,
1524 sizeof(struct sockaddr_in), 0);
1530 psin_server->sin_port = htons(RFC1001_PORT);
1531 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1533 sizeof(struct sockaddr_in), 0);
1538 /* give up here - unless we want to retry on different
1539 protocol families some day */
1542 psin_server->sin_port = orig_port;
1543 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1544 sock_release(*csocket);
1548 /* Eventually check for other socket options to change from
1549 the default. sock_setsockopt not used because it expects
1550 user space buffer */
1551 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1552 (*csocket)->sk->sk_sndbuf,
1553 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1554 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1555 /* make the bufsizes depend on wsize/rsize and max requests */
1556 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1557 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1558 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1559 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1561 /* send RFC1001 sessinit */
1562 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1563 /* some servers require RFC1001 sessinit before sending
1564 negprot - BB check reconnection in case where second
1565 sessinit is sent but no second negprot */
1566 struct rfc1002_session_packet *ses_init_buf;
1567 struct smb_hdr *smb_buf;
1568 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1571 ses_init_buf->trailer.session_req.called_len = 32;
1572 if (target_name && (target_name[0] != 0)) {
1573 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1576 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1577 DEFAULT_CIFS_CALLED_NAME, 16);
1580 ses_init_buf->trailer.session_req.calling_len = 32;
1581 /* calling name ends in null (byte 16) from old smb
1583 if (netbios_name && (netbios_name[0] != 0)) {
1584 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1587 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1588 "LINUX_CIFS_CLNT", 16);
1590 ses_init_buf->trailer.session_req.scope1 = 0;
1591 ses_init_buf->trailer.session_req.scope2 = 0;
1592 smb_buf = (struct smb_hdr *)ses_init_buf;
1593 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1594 smb_buf->smb_buf_length = 0x81000044;
1595 rc = smb_send(*csocket, smb_buf, 0x44,
1596 (struct sockaddr *)psin_server);
1597 kfree(ses_init_buf);
1598 msleep(1); /* RFC1001 layer in at least one server
1599 requires very short break before negprot
1600 presumably because not expecting negprot
1601 to follow so fast. This is a simple
1602 solution that works without
1603 complicating the code and causes no
1604 significant slowing down on mount
1605 for everyone else */
1607 /* else the negprot may still work without this
1608 even though malloc failed */
1616 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1620 __be16 orig_port = 0;
1622 if (*csocket == NULL) {
1623 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1624 IPPROTO_TCP, csocket);
1626 cERROR(1, ("Error %d creating ipv6 socket", rc));
1630 /* BB other socket options to set KEEPALIVE, NODELAY? */
1631 cFYI(1, ("ipv6 Socket created"));
1632 (*csocket)->sk->sk_allocation = GFP_NOFS;
1636 psin_server->sin6_family = AF_INET6;
1638 if (psin_server->sin6_port) { /* user overrode default port */
1639 rc = (*csocket)->ops->connect(*csocket,
1640 (struct sockaddr *) psin_server,
1641 sizeof(struct sockaddr_in6), 0);
1647 /* save original port so we can retry user specified port
1648 later if fall back ports fail this time */
1650 orig_port = psin_server->sin6_port;
1651 /* do not retry on the same port we just failed on */
1652 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1653 psin_server->sin6_port = htons(CIFS_PORT);
1655 rc = (*csocket)->ops->connect(*csocket,
1656 (struct sockaddr *) psin_server,
1657 sizeof(struct sockaddr_in6), 0);
1663 psin_server->sin6_port = htons(RFC1001_PORT);
1664 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1665 psin_server, sizeof(struct sockaddr_in6), 0);
1670 /* give up here - unless we want to retry on different
1671 protocol families some day */
1674 psin_server->sin6_port = orig_port;
1675 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1676 sock_release(*csocket);
1680 /* Eventually check for other socket options to change from
1681 the default. sock_setsockopt not used because it expects
1682 user space buffer */
1683 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1688 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1689 struct super_block *sb, struct smb_vol *vol_info)
1691 /* if we are reconnecting then should we check to see if
1692 * any requested capabilities changed locally e.g. via
1693 * remount but we can not do much about it here
1694 * if they have (even if we could detect it by the following)
1695 * Perhaps we could add a backpointer to array of sb from tcon
1696 * or if we change to make all sb to same share the same
1697 * sb as NFS - then we only have one backpointer to sb.
1698 * What if we wanted to mount the server share twice once with
1699 * and once without posixacls or posix paths? */
1700 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1702 if (vol_info && vol_info->no_linux_ext) {
1703 tcon->fsUnixInfo.Capability = 0;
1704 tcon->unix_ext = 0; /* Unix Extensions disabled */
1705 cFYI(1, ("Linux protocol extensions disabled"));
1707 } else if (vol_info)
1708 tcon->unix_ext = 1; /* Unix Extensions supported */
1710 if (tcon->unix_ext == 0) {
1711 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1715 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1716 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1718 /* check for reconnect case in which we do not
1719 want to change the mount behavior if we can avoid it */
1720 if (vol_info == NULL) {
1721 /* turn off POSIX ACL and PATHNAMES if not set
1722 originally at mount time */
1723 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1724 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1725 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
1726 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1729 cap &= CIFS_UNIX_CAP_MASK;
1730 if (vol_info && vol_info->no_psx_acl)
1731 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1732 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1733 cFYI(1, ("negotiated posix acl support"));
1735 sb->s_flags |= MS_POSIXACL;
1738 if (vol_info && vol_info->posix_paths == 0)
1739 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1740 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1741 cFYI(1, ("negotiate posix pathnames"));
1743 CIFS_SB(sb)->mnt_cifs_flags |=
1744 CIFS_MOUNT_POSIX_PATHS;
1747 /* We might be setting the path sep back to a different
1748 form if we are reconnecting and the server switched its
1749 posix path capability for this share */
1750 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1751 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1753 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1754 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1755 CIFS_SB(sb)->rsize = 127 * 1024;
1757 ("larger reads not supported by srv"));
1762 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1763 #ifdef CONFIG_CIFS_DEBUG2
1764 if (cap & CIFS_UNIX_FCNTL_CAP)
1765 cFYI(1, ("FCNTL cap"));
1766 if (cap & CIFS_UNIX_EXTATTR_CAP)
1767 cFYI(1, ("EXTATTR cap"));
1768 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1769 cFYI(1, ("POSIX path cap"));
1770 if (cap & CIFS_UNIX_XATTR_CAP)
1771 cFYI(1, ("XATTR cap"));
1772 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1773 cFYI(1, ("POSIX ACL cap"));
1774 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1775 cFYI(1, ("very large read cap"));
1776 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1777 cFYI(1, ("very large write cap"));
1778 #endif /* CIFS_DEBUG2 */
1779 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1780 if (vol_info == NULL) {
1781 cFYI(1, ("resetting capabilities failed"));
1783 cERROR(1, ("Negotiating Unix capabilities "
1784 "with the server failed. Consider "
1785 "mounting with the Unix Extensions\n"
1786 "disabled, if problems are found, "
1787 "by specifying the nounix mount "
1795 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1796 char *mount_data, const char *devname)
1800 int address_type = AF_INET;
1801 struct socket *csocket = NULL;
1802 struct sockaddr_in sin_server;
1803 struct sockaddr_in6 sin_server6;
1804 struct smb_vol volume_info;
1805 struct cifsSesInfo *pSesInfo = NULL;
1806 struct cifsSesInfo *existingCifsSes = NULL;
1807 struct cifsTconInfo *tcon = NULL;
1808 struct TCP_Server_Info *srvTcp = NULL;
1812 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1814 memset(&volume_info, 0, sizeof(struct smb_vol));
1815 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1820 if (volume_info.nullauth) {
1821 cFYI(1, ("null user"));
1822 volume_info.username = "";
1823 } else if (volume_info.username) {
1824 /* BB fixme parse for domain name here */
1825 cFYI(1, ("Username: %s", volume_info.username));
1827 cifserror("No username specified");
1828 /* In userspace mount helper we can get user name from alternate
1829 locations such as env variables and files on disk */
1834 if (volume_info.UNCip && volume_info.UNC) {
1835 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1836 &sin_server.sin_addr.s_addr);
1839 /* not ipv4 address, try ipv6 */
1840 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1841 &sin_server6.sin6_addr.in6_u);
1843 address_type = AF_INET6;
1845 address_type = AF_INET;
1849 /* we failed translating address */
1854 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1857 } else if (volume_info.UNCip) {
1858 /* BB using ip addr as server name to connect to the
1860 cERROR(1, ("Connecting to DFS root not implemented yet"));
1863 } else /* which servers DFS root would we conect to */ {
1865 ("CIFS mount error: No UNC path (e.g. -o "
1866 "unc=//192.168.1.100/public) specified"));
1871 /* this is needed for ASCII cp to Unicode converts */
1872 if (volume_info.iocharset == NULL) {
1873 cifs_sb->local_nls = load_nls_default();
1874 /* load_nls_default can not return null */
1876 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1877 if (cifs_sb->local_nls == NULL) {
1878 cERROR(1, ("CIFS mount error: iocharset %s not found",
1879 volume_info.iocharset));
1885 if (address_type == AF_INET)
1886 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1887 NULL /* no ipv6 addr */,
1888 volume_info.username, &srvTcp);
1889 else if (address_type == AF_INET6) {
1890 cFYI(1, ("looking for ipv6 address"));
1891 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1892 &sin_server6.sin6_addr,
1893 volume_info.username, &srvTcp);
1900 cFYI(1, ("Existing tcp session with server found"));
1901 } else { /* create socket */
1902 if (volume_info.port)
1903 sin_server.sin_port = htons(volume_info.port);
1905 sin_server.sin_port = 0;
1906 if (address_type == AF_INET6) {
1907 cFYI(1, ("attempting ipv6 connect"));
1908 /* BB should we allow ipv6 on port 139? */
1909 /* other OS never observed in Wild doing 139 with v6 */
1910 rc = ipv6_connect(&sin_server6, &csocket);
1912 rc = ipv4_connect(&sin_server, &csocket,
1913 volume_info.source_rfc1001_name,
1914 volume_info.target_rfc1001_name);
1916 cERROR(1, ("Error connecting to IPv4 socket. "
1917 "Aborting operation"));
1918 if (csocket != NULL)
1919 sock_release(csocket);
1923 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1926 sock_release(csocket);
1929 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1930 sizeof(struct sockaddr_in));
1931 atomic_set(&srvTcp->inFlight, 0);
1932 /* BB Add code for ipv6 case too */
1933 srvTcp->ssocket = csocket;
1934 srvTcp->protocolType = IPV4;
1935 srvTcp->hostname = extract_hostname(volume_info.UNC);
1936 if (IS_ERR(srvTcp->hostname)) {
1937 rc = PTR_ERR(srvTcp->hostname);
1938 sock_release(csocket);
1941 init_waitqueue_head(&srvTcp->response_q);
1942 init_waitqueue_head(&srvTcp->request_q);
1943 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1944 /* at this point we are the only ones with the pointer
1945 to the struct since the kernel thread not created yet
1946 so no need to spinlock this init of tcpStatus */
1947 srvTcp->tcpStatus = CifsNew;
1948 init_MUTEX(&srvTcp->tcpSem);
1949 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1950 if (IS_ERR(srvTcp->tsk)) {
1951 rc = PTR_ERR(srvTcp->tsk);
1952 cERROR(1, ("error %d create cifsd thread", rc));
1954 sock_release(csocket);
1955 kfree(srvTcp->hostname);
1958 wait_for_completion(&cifsd_complete);
1960 memcpy(srvTcp->workstation_RFC1001_name,
1961 volume_info.source_rfc1001_name, 16);
1962 memcpy(srvTcp->server_RFC1001_name,
1963 volume_info.target_rfc1001_name, 16);
1964 srvTcp->sequence_number = 0;
1968 if (existingCifsSes) {
1969 pSesInfo = existingCifsSes;
1970 cFYI(1, ("Existing smb sess found (status=%d)",
1972 down(&pSesInfo->sesSem);
1973 if (pSesInfo->status == CifsNeedReconnect) {
1974 cFYI(1, ("Session needs reconnect"));
1975 rc = cifs_setup_session(xid, pSesInfo,
1976 cifs_sb->local_nls);
1978 up(&pSesInfo->sesSem);
1980 cFYI(1, ("Existing smb sess not found"));
1981 pSesInfo = sesInfoAlloc();
1982 if (pSesInfo == NULL)
1985 pSesInfo->server = srvTcp;
1986 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
1987 NIPQUAD(sin_server.sin_addr.s_addr));
1991 /* volume_info.password freed at unmount */
1992 if (volume_info.password) {
1993 pSesInfo->password = volume_info.password;
1994 /* set to NULL to prevent freeing on exit */
1995 volume_info.password = NULL;
1997 if (volume_info.username)
1998 strncpy(pSesInfo->userName,
1999 volume_info.username,
2001 if (volume_info.domainname) {
2002 int len = strlen(volume_info.domainname);
2003 pSesInfo->domainName =
2004 kmalloc(len + 1, GFP_KERNEL);
2005 if (pSesInfo->domainName)
2006 strcpy(pSesInfo->domainName,
2007 volume_info.domainname);
2009 pSesInfo->linux_uid = volume_info.linux_uid;
2010 pSesInfo->overrideSecFlg = volume_info.secFlg;
2011 down(&pSesInfo->sesSem);
2012 /* BB FIXME need to pass vol->secFlgs BB */
2013 rc = cifs_setup_session(xid, pSesInfo,
2014 cifs_sb->local_nls);
2015 up(&pSesInfo->sesSem);
2017 atomic_inc(&srvTcp->socketUseCount);
2021 /* search for existing tcon to this server share */
2023 if (volume_info.rsize > CIFSMaxBufSize) {
2024 cERROR(1, ("rsize %d too large, using MaxBufSize",
2025 volume_info.rsize));
2026 cifs_sb->rsize = CIFSMaxBufSize;
2027 } else if ((volume_info.rsize) &&
2028 (volume_info.rsize <= CIFSMaxBufSize))
2029 cifs_sb->rsize = volume_info.rsize;
2031 cifs_sb->rsize = CIFSMaxBufSize;
2033 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2034 cERROR(1, ("wsize %d too large, using 4096 instead",
2035 volume_info.wsize));
2036 cifs_sb->wsize = 4096;
2037 } else if (volume_info.wsize)
2038 cifs_sb->wsize = volume_info.wsize;
2041 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2043 /* old default of CIFSMaxBufSize was too small now
2044 that SMB Write2 can send multiple pages in kvec.
2045 RFC1001 does not describe what happens when frame
2046 bigger than 128K is sent so use that as max in
2047 conjunction with 52K kvec constraint on arch with 4K
2050 if (cifs_sb->rsize < 2048) {
2051 cifs_sb->rsize = 2048;
2052 /* Windows ME may prefer this */
2053 cFYI(1, ("readsize set to minimum: 2048"));
2055 /* calculate prepath */
2056 cifs_sb->prepath = volume_info.prepath;
2057 if (cifs_sb->prepath) {
2058 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2059 cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
2060 volume_info.prepath = NULL;
2062 cifs_sb->prepathlen = 0;
2063 cifs_sb->mnt_uid = volume_info.linux_uid;
2064 cifs_sb->mnt_gid = volume_info.linux_gid;
2065 cifs_sb->mnt_file_mode = volume_info.file_mode;
2066 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2067 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2068 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2070 if (volume_info.noperm)
2071 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2072 if (volume_info.setuids)
2073 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2074 if (volume_info.server_ino)
2075 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2076 if (volume_info.remap)
2077 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2078 if (volume_info.no_xattr)
2079 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2080 if (volume_info.sfu_emul)
2081 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2082 if (volume_info.nobrl)
2083 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2084 if (volume_info.cifs_acl)
2085 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2086 if (volume_info.override_uid)
2087 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2088 if (volume_info.override_gid)
2089 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2090 if (volume_info.direct_io) {
2091 cFYI(1, ("mounting share using direct i/o"));
2092 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2096 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2097 volume_info.username);
2099 cFYI(1, ("Found match on UNC path"));
2100 /* we can have only one retry value for a connection
2101 to a share so for resources mounted more than once
2102 to the same server share the last value passed in
2103 for the retry flag is used */
2104 tcon->retry = volume_info.retry;
2105 tcon->nocase = volume_info.nocase;
2107 tcon = tconInfoAlloc();
2111 /* check for null share name ie connecting to
2114 /* BB check if this works for exactly length
2116 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2117 && (strchr(volume_info.UNC + 3, '/') ==
2119 rc = connect_to_dfs_path(xid, pSesInfo,
2120 "", cifs_sb->local_nls,
2121 cifs_sb->mnt_cifs_flags &
2122 CIFS_MOUNT_MAP_SPECIAL_CHR);
2126 /* BB Do we need to wrap sesSem around
2127 * this TCon call and Unix SetFS as
2128 * we do on SessSetup and reconnect? */
2129 rc = CIFSTCon(xid, pSesInfo,
2131 tcon, cifs_sb->local_nls);
2132 cFYI(1, ("CIFS Tcon rc = %d", rc));
2135 atomic_inc(&pSesInfo->inUse);
2136 tcon->retry = volume_info.retry;
2137 tcon->nocase = volume_info.nocase;
2143 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2144 sb->s_maxbytes = (u64) 1 << 63;
2146 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2149 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2150 sb->s_time_gran = 100;
2152 /* on error free sesinfo and tcon struct if needed */
2154 /* if session setup failed, use count is zero but
2155 we still need to free cifsd thread */
2156 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2157 spin_lock(&GlobalMid_Lock);
2158 srvTcp->tcpStatus = CifsExiting;
2159 spin_unlock(&GlobalMid_Lock);
2161 struct task_struct *tsk;
2162 /* If we could verify that kthread_stop would
2163 always wake up processes blocked in
2164 tcp in recv_mesg then we could remove the
2166 force_sig(SIGKILL, srvTcp->tsk);
2172 /* If find_unc succeeded then rc == 0 so we can not end */
2173 if (tcon) /* up accidently freeing someone elses tcon struct */
2175 if (existingCifsSes == NULL) {
2177 if ((pSesInfo->server) &&
2178 (pSesInfo->status == CifsGood)) {
2180 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2181 /* if the socketUseCount is now zero */
2182 if ((temp_rc == -ESHUTDOWN) &&
2183 (pSesInfo->server) &&
2184 (pSesInfo->server->tsk)) {
2185 struct task_struct *tsk;
2187 pSesInfo->server->tsk);
2188 tsk = pSesInfo->server->tsk;
2193 cFYI(1, ("No session or bad tcon"));
2194 if ((pSesInfo->server) &&
2195 (pSesInfo->server->tsk)) {
2196 struct task_struct *tsk;
2198 pSesInfo->server->tsk);
2199 tsk = pSesInfo->server->tsk;
2204 sesInfoFree(pSesInfo);
2205 /* pSesInfo = NULL; */
2209 atomic_inc(&tcon->useCount);
2210 cifs_sb->tcon = tcon;
2211 tcon->ses = pSesInfo;
2213 /* do not care if following two calls succeed - informational */
2215 CIFSSMBQFSDeviceInfo(xid, tcon);
2216 CIFSSMBQFSAttributeInfo(xid, tcon);
2219 /* tell server which Unix caps we support */
2220 if (tcon->ses->capabilities & CAP_UNIX)
2221 /* reset of caps checks mount to see if unix extensions
2222 disabled for just this mount */
2223 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2225 tcon->unix_ext = 0; /* server does not support them */
2227 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2228 cifs_sb->rsize = 1024 * 127;
2230 ("no very large read support, rsize now 127K"));
2232 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2233 cifs_sb->wsize = min(cifs_sb->wsize,
2234 (tcon->ses->server->maxBuf -
2235 MAX_CIFS_HDR_SIZE));
2236 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2237 cifs_sb->rsize = min(cifs_sb->rsize,
2238 (tcon->ses->server->maxBuf -
2239 MAX_CIFS_HDR_SIZE));
2242 /* volume_info.password is freed above when existing session found
2243 (in which case it is not needed anymore) but when new sesion is created
2244 the password ptr is put in the new session structure (in which case the
2245 password will be freed at unmount time) */
2247 /* zero out password before freeing */
2248 if (volume_info.password != NULL) {
2249 memset(volume_info.password, 0, strlen(volume_info.password));
2250 kfree(volume_info.password);
2252 kfree(volume_info.UNC);
2253 kfree(volume_info.prepath);
2259 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2260 char session_key[CIFS_SESS_KEY_SIZE],
2261 const struct nls_table *nls_codepage)
2263 struct smb_hdr *smb_buffer;
2264 struct smb_hdr *smb_buffer_response;
2265 SESSION_SETUP_ANDX *pSMB;
2266 SESSION_SETUP_ANDX *pSMBr;
2271 int remaining_words = 0;
2272 int bytes_returned = 0;
2277 cFYI(1, ("In sesssetup"));
2280 user = ses->userName;
2281 domain = ses->domainName;
2282 smb_buffer = cifs_buf_get();
2283 if (smb_buffer == NULL) {
2286 smb_buffer_response = smb_buffer;
2287 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2289 /* send SMBsessionSetup here */
2290 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2291 NULL /* no tCon exists yet */ , 13 /* wct */ );
2293 smb_buffer->Mid = GetNextMid(ses->server);
2294 pSMB->req_no_secext.AndXCommand = 0xFF;
2295 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2296 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2298 if (ses->server->secMode &
2299 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2300 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2302 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2303 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2304 if (ses->capabilities & CAP_UNICODE) {
2305 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2306 capabilities |= CAP_UNICODE;
2308 if (ses->capabilities & CAP_STATUS32) {
2309 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2310 capabilities |= CAP_STATUS32;
2312 if (ses->capabilities & CAP_DFS) {
2313 smb_buffer->Flags2 |= SMBFLG2_DFS;
2314 capabilities |= CAP_DFS;
2316 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2318 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2319 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2321 pSMB->req_no_secext.CaseSensitivePasswordLength =
2322 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2323 bcc_ptr = pByteArea(smb_buffer);
2324 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2325 bcc_ptr += CIFS_SESS_KEY_SIZE;
2326 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2327 bcc_ptr += CIFS_SESS_KEY_SIZE;
2329 if (ses->capabilities & CAP_UNICODE) {
2330 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2335 bytes_returned = 0; /* skip null user */
2338 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2340 /* convert number of 16 bit words to bytes */
2341 bcc_ptr += 2 * bytes_returned;
2342 bcc_ptr += 2; /* trailing null */
2345 cifs_strtoUCS((__le16 *) bcc_ptr,
2346 "CIFS_LINUX_DOM", 32, nls_codepage);
2349 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2351 bcc_ptr += 2 * bytes_returned;
2354 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2356 bcc_ptr += 2 * bytes_returned;
2358 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2360 bcc_ptr += 2 * bytes_returned;
2363 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2365 bcc_ptr += 2 * bytes_returned;
2369 strncpy(bcc_ptr, user, 200);
2370 bcc_ptr += strnlen(user, 200);
2374 if (domain == NULL) {
2375 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2376 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2378 strncpy(bcc_ptr, domain, 64);
2379 bcc_ptr += strnlen(domain, 64);
2383 strcpy(bcc_ptr, "Linux version ");
2384 bcc_ptr += strlen("Linux version ");
2385 strcpy(bcc_ptr, utsname()->release);
2386 bcc_ptr += strlen(utsname()->release) + 1;
2387 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2388 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2390 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2391 smb_buffer->smb_buf_length += count;
2392 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2394 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2395 &bytes_returned, CIFS_LONG_OP);
2397 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2398 } else if ((smb_buffer_response->WordCount == 3)
2399 || (smb_buffer_response->WordCount == 4)) {
2400 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2401 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2402 if (action & GUEST_LOGIN)
2403 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2404 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2406 cFYI(1, ("UID = %d ", ses->Suid));
2407 /* response can have either 3 or 4 word count - Samba sends 3 */
2408 bcc_ptr = pByteArea(smb_buffer_response);
2409 if ((pSMBr->resp.hdr.WordCount == 3)
2410 || ((pSMBr->resp.hdr.WordCount == 4)
2411 && (blob_len < pSMBr->resp.ByteCount))) {
2412 if (pSMBr->resp.hdr.WordCount == 4)
2413 bcc_ptr += blob_len;
2415 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2416 if ((long) (bcc_ptr) % 2) {
2418 (BCC(smb_buffer_response) - 1) / 2;
2419 /* Unicode strings must be word
2424 BCC(smb_buffer_response) / 2;
2427 UniStrnlen((wchar_t *) bcc_ptr,
2428 remaining_words - 1);
2429 /* We look for obvious messed up bcc or strings in response so we do not go off
2430 the end since (at least) WIN2K and Windows XP have a major bug in not null
2431 terminating last Unicode string in response */
2433 kfree(ses->serverOS);
2434 ses->serverOS = kzalloc(2 * (len + 1),
2436 if (ses->serverOS == NULL)
2437 goto sesssetup_nomem;
2438 cifs_strfromUCS_le(ses->serverOS,
2441 bcc_ptr += 2 * (len + 1);
2442 remaining_words -= len + 1;
2443 ses->serverOS[2 * len] = 0;
2444 ses->serverOS[1 + (2 * len)] = 0;
2445 if (remaining_words > 0) {
2446 len = UniStrnlen((wchar_t *)bcc_ptr,
2448 kfree(ses->serverNOS);
2449 ses->serverNOS = kzalloc(2 * (len + 1),
2451 if (ses->serverNOS == NULL)
2452 goto sesssetup_nomem;
2453 cifs_strfromUCS_le(ses->serverNOS,
2456 bcc_ptr += 2 * (len + 1);
2457 ses->serverNOS[2 * len] = 0;
2458 ses->serverNOS[1 + (2 * len)] = 0;
2459 if (strncmp(ses->serverNOS,
2460 "NT LAN Manager 4", 16) == 0) {
2461 cFYI(1, ("NT4 server"));
2462 ses->flags |= CIFS_SES_NT4;
2464 remaining_words -= len + 1;
2465 if (remaining_words > 0) {
2466 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2467 /* last string is not always null terminated
2468 (for e.g. for Windows XP & 2000) */
2469 if (ses->serverDomain)
2470 kfree(ses->serverDomain);
2474 if (ses->serverDomain == NULL)
2475 goto sesssetup_nomem;
2476 cifs_strfromUCS_le(ses->serverDomain,
2479 bcc_ptr += 2 * (len + 1);
2480 ses->serverDomain[2*len] = 0;
2481 ses->serverDomain[1+(2*len)] = 0;
2482 } else { /* else no more room so create
2483 dummy domain string */
2484 if (ses->serverDomain)
2485 kfree(ses->serverDomain);
2487 kzalloc(2, GFP_KERNEL);
2489 } else { /* no room so create dummy domain
2492 /* if these kcallocs fail not much we
2493 can do, but better to not fail the
2495 kfree(ses->serverDomain);
2497 kzalloc(2, GFP_KERNEL);
2498 kfree(ses->serverNOS);
2500 kzalloc(2, GFP_KERNEL);
2502 } else { /* ASCII */
2503 len = strnlen(bcc_ptr, 1024);
2504 if (((long) bcc_ptr + len) - (long)
2505 pByteArea(smb_buffer_response)
2506 <= BCC(smb_buffer_response)) {
2507 kfree(ses->serverOS);
2508 ses->serverOS = kzalloc(len + 1,
2510 if (ses->serverOS == NULL)
2511 goto sesssetup_nomem;
2512 strncpy(ses->serverOS, bcc_ptr, len);
2515 /* null terminate the string */
2519 len = strnlen(bcc_ptr, 1024);
2520 kfree(ses->serverNOS);
2521 ses->serverNOS = kzalloc(len + 1,
2523 if (ses->serverNOS == NULL)
2524 goto sesssetup_nomem;
2525 strncpy(ses->serverNOS, bcc_ptr, len);
2530 len = strnlen(bcc_ptr, 1024);
2531 if (ses->serverDomain)
2532 kfree(ses->serverDomain);
2533 ses->serverDomain = kzalloc(len + 1,
2535 if (ses->serverDomain == NULL)
2536 goto sesssetup_nomem;
2537 strncpy(ses->serverDomain, bcc_ptr,
2544 ("Variable field of length %d "
2545 "extends beyond end of smb ",
2550 (" Security Blob Length extends beyond "
2555 (" Invalid Word count %d: ",
2556 smb_buffer_response->WordCount));
2559 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2560 since that could make reconnection harder, and
2561 reconnection might be needed to free memory */
2562 cifs_buf_release(smb_buffer);
2568 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2569 struct cifsSesInfo *ses, int *pNTLMv2_flag,
2570 const struct nls_table *nls_codepage)
2572 struct smb_hdr *smb_buffer;
2573 struct smb_hdr *smb_buffer_response;
2574 SESSION_SETUP_ANDX *pSMB;
2575 SESSION_SETUP_ANDX *pSMBr;
2579 int remaining_words = 0;
2580 int bytes_returned = 0;
2582 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2583 PNEGOTIATE_MESSAGE SecurityBlob;
2584 PCHALLENGE_MESSAGE SecurityBlob2;
2585 __u32 negotiate_flags, capabilities;
2588 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2591 domain = ses->domainName;
2592 *pNTLMv2_flag = FALSE;
2593 smb_buffer = cifs_buf_get();
2594 if (smb_buffer == NULL) {
2597 smb_buffer_response = smb_buffer;
2598 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2599 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2601 /* send SMBsessionSetup here */
2602 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2603 NULL /* no tCon exists yet */ , 12 /* wct */ );
2605 smb_buffer->Mid = GetNextMid(ses->server);
2606 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2607 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2609 pSMB->req.AndXCommand = 0xFF;
2610 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2611 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2613 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2614 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2616 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2617 CAP_EXTENDED_SECURITY;
2618 if (ses->capabilities & CAP_UNICODE) {
2619 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2620 capabilities |= CAP_UNICODE;
2622 if (ses->capabilities & CAP_STATUS32) {
2623 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2624 capabilities |= CAP_STATUS32;
2626 if (ses->capabilities & CAP_DFS) {
2627 smb_buffer->Flags2 |= SMBFLG2_DFS;
2628 capabilities |= CAP_DFS;
2630 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2632 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2633 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2634 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2635 SecurityBlob->MessageType = NtLmNegotiate;
2637 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2638 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2639 NTLMSSP_NEGOTIATE_56 |
2640 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2642 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2643 /* if (ntlmv2_support)
2644 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2645 /* setup pointers to domain name and workstation name */
2646 bcc_ptr += SecurityBlobLength;
2648 SecurityBlob->WorkstationName.Buffer = 0;
2649 SecurityBlob->WorkstationName.Length = 0;
2650 SecurityBlob->WorkstationName.MaximumLength = 0;
2652 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2653 along with username on auth request (ie the response to challenge) */
2654 SecurityBlob->DomainName.Buffer = 0;
2655 SecurityBlob->DomainName.Length = 0;
2656 SecurityBlob->DomainName.MaximumLength = 0;
2657 if (ses->capabilities & CAP_UNICODE) {
2658 if ((long) bcc_ptr % 2) {
2664 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2666 bcc_ptr += 2 * bytes_returned;
2668 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2670 bcc_ptr += 2 * bytes_returned;
2671 bcc_ptr += 2; /* null terminate Linux version */
2673 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2675 bcc_ptr += 2 * bytes_returned;
2678 bcc_ptr += 2; /* null terminate network opsys string */
2681 bcc_ptr += 2; /* null domain */
2682 } else { /* ASCII */
2683 strcpy(bcc_ptr, "Linux version ");
2684 bcc_ptr += strlen("Linux version ");
2685 strcpy(bcc_ptr, utsname()->release);
2686 bcc_ptr += strlen(utsname()->release) + 1;
2687 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2688 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2689 bcc_ptr++; /* empty domain field */
2692 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2693 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2694 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2695 smb_buffer->smb_buf_length += count;
2696 pSMB->req.ByteCount = cpu_to_le16(count);
2698 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2699 &bytes_returned, CIFS_LONG_OP);
2701 if (smb_buffer_response->Status.CifsError ==
2702 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2706 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2707 } else if ((smb_buffer_response->WordCount == 3)
2708 || (smb_buffer_response->WordCount == 4)) {
2709 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2710 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2712 if (action & GUEST_LOGIN)
2713 cFYI(1, (" Guest login"));
2714 /* Do we want to set anything in SesInfo struct when guest login? */
2716 bcc_ptr = pByteArea(smb_buffer_response);
2717 /* response can have either 3 or 4 word count - Samba sends 3 */
2719 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2720 if (SecurityBlob2->MessageType != NtLmChallenge) {
2722 ("Unexpected NTLMSSP message type received %d",
2723 SecurityBlob2->MessageType));
2725 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2726 cFYI(1, ("UID = %d", ses->Suid));
2727 if ((pSMBr->resp.hdr.WordCount == 3)
2728 || ((pSMBr->resp.hdr.WordCount == 4)
2730 pSMBr->resp.ByteCount))) {
2732 if (pSMBr->resp.hdr.WordCount == 4) {
2733 bcc_ptr += blob_len;
2734 cFYI(1, ("Security Blob Length %d",
2738 cFYI(1, ("NTLMSSP Challenge rcvd"));
2740 memcpy(ses->server->cryptKey,
2741 SecurityBlob2->Challenge,
2742 CIFS_CRYPTO_KEY_SIZE);
2743 if (SecurityBlob2->NegotiateFlags &
2744 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2745 *pNTLMv2_flag = TRUE;
2747 if ((SecurityBlob2->NegotiateFlags &
2748 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2749 || (sign_CIFS_PDUs > 1))
2750 ses->server->secMode |=
2751 SECMODE_SIGN_REQUIRED;
2752 if ((SecurityBlob2->NegotiateFlags &
2753 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2754 ses->server->secMode |=
2755 SECMODE_SIGN_ENABLED;
2757 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2758 if ((long) (bcc_ptr) % 2) {
2760 (BCC(smb_buffer_response)
2762 /* Must word align unicode strings */
2767 (smb_buffer_response) / 2;
2770 UniStrnlen((wchar_t *) bcc_ptr,
2771 remaining_words - 1);
2772 /* We look for obvious messed up bcc or strings in response so we do not go off
2773 the end since (at least) WIN2K and Windows XP have a major bug in not null
2774 terminating last Unicode string in response */
2776 kfree(ses->serverOS);
2778 kzalloc(2 * (len + 1), GFP_KERNEL);
2779 cifs_strfromUCS_le(ses->serverOS,
2783 bcc_ptr += 2 * (len + 1);
2784 remaining_words -= len + 1;
2785 ses->serverOS[2 * len] = 0;
2786 ses->serverOS[1 + (2 * len)] = 0;
2787 if (remaining_words > 0) {
2788 len = UniStrnlen((wchar_t *)
2792 kfree(ses->serverNOS);
2794 kzalloc(2 * (len + 1),
2796 cifs_strfromUCS_le(ses->
2802 bcc_ptr += 2 * (len + 1);
2803 ses->serverNOS[2 * len] = 0;
2806 remaining_words -= len + 1;
2807 if (remaining_words > 0) {
2808 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2809 /* last string not always null terminated
2810 (for e.g. for Windows XP & 2000) */
2811 kfree(ses->serverDomain);
2823 ses->serverDomain[2*len]
2828 } /* else no more room so create dummy domain string */
2830 kfree(ses->serverDomain);
2835 } else { /* no room so create dummy domain and NOS string */
2836 kfree(ses->serverDomain);
2838 kzalloc(2, GFP_KERNEL);
2839 kfree(ses->serverNOS);
2841 kzalloc(2, GFP_KERNEL);
2843 } else { /* ASCII */
2844 len = strnlen(bcc_ptr, 1024);
2845 if (((long) bcc_ptr + len) - (long)
2846 pByteArea(smb_buffer_response)
2847 <= BCC(smb_buffer_response)) {
2849 kfree(ses->serverOS);
2853 strncpy(ses->serverOS,
2857 bcc_ptr[0] = 0; /* null terminate string */
2860 len = strnlen(bcc_ptr, 1024);
2861 kfree(ses->serverNOS);
2865 strncpy(ses->serverNOS, bcc_ptr, len);
2870 len = strnlen(bcc_ptr, 1024);
2871 kfree(ses->serverDomain);
2875 strncpy(ses->serverDomain,
2882 ("field of length %d "
2883 "extends beyond end of smb",
2887 cERROR(1, ("Security Blob Length extends beyond"
2891 cERROR(1, ("No session structure passed in."));
2895 (" Invalid Word count %d:",
2896 smb_buffer_response->WordCount));
2900 cifs_buf_release(smb_buffer);
2905 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2906 char *ntlm_session_key, int ntlmv2_flag,
2907 const struct nls_table *nls_codepage)
2909 struct smb_hdr *smb_buffer;
2910 struct smb_hdr *smb_buffer_response;
2911 SESSION_SETUP_ANDX *pSMB;
2912 SESSION_SETUP_ANDX *pSMBr;
2917 int remaining_words = 0;
2918 int bytes_returned = 0;
2920 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2921 PAUTHENTICATE_MESSAGE SecurityBlob;
2922 __u32 negotiate_flags, capabilities;
2925 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2928 user = ses->userName;
2929 domain = ses->domainName;
2930 smb_buffer = cifs_buf_get();
2931 if (smb_buffer == NULL) {
2934 smb_buffer_response = smb_buffer;
2935 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
2936 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
2938 /* send SMBsessionSetup here */
2939 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2940 NULL /* no tCon exists yet */ , 12 /* wct */ );
2942 smb_buffer->Mid = GetNextMid(ses->server);
2943 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2944 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2945 pSMB->req.AndXCommand = 0xFF;
2946 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2947 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2949 pSMB->req.hdr.Uid = ses->Suid;
2951 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2952 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2954 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2955 CAP_EXTENDED_SECURITY;
2956 if (ses->capabilities & CAP_UNICODE) {
2957 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2958 capabilities |= CAP_UNICODE;
2960 if (ses->capabilities & CAP_STATUS32) {
2961 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2962 capabilities |= CAP_STATUS32;
2964 if (ses->capabilities & CAP_DFS) {
2965 smb_buffer->Flags2 |= SMBFLG2_DFS;
2966 capabilities |= CAP_DFS;
2968 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2970 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
2971 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
2972 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2973 SecurityBlob->MessageType = NtLmAuthenticate;
2974 bcc_ptr += SecurityBlobLength;
2975 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
2976 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
2977 0x80000000 | NTLMSSP_NEGOTIATE_128;
2979 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
2981 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
2983 /* setup pointers to domain name and workstation name */
2985 SecurityBlob->WorkstationName.Buffer = 0;
2986 SecurityBlob->WorkstationName.Length = 0;
2987 SecurityBlob->WorkstationName.MaximumLength = 0;
2988 SecurityBlob->SessionKey.Length = 0;
2989 SecurityBlob->SessionKey.MaximumLength = 0;
2990 SecurityBlob->SessionKey.Buffer = 0;
2992 SecurityBlob->LmChallengeResponse.Length = 0;
2993 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
2994 SecurityBlob->LmChallengeResponse.Buffer = 0;
2996 SecurityBlob->NtChallengeResponse.Length =
2997 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2998 SecurityBlob->NtChallengeResponse.MaximumLength =
2999 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3000 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3001 SecurityBlob->NtChallengeResponse.Buffer =
3002 cpu_to_le32(SecurityBlobLength);
3003 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3004 bcc_ptr += CIFS_SESS_KEY_SIZE;
3006 if (ses->capabilities & CAP_UNICODE) {
3007 if (domain == NULL) {
3008 SecurityBlob->DomainName.Buffer = 0;
3009 SecurityBlob->DomainName.Length = 0;
3010 SecurityBlob->DomainName.MaximumLength = 0;
3012 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3015 SecurityBlob->DomainName.MaximumLength =
3017 SecurityBlob->DomainName.Buffer =
3018 cpu_to_le32(SecurityBlobLength);
3020 SecurityBlobLength += ln;
3021 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3024 SecurityBlob->UserName.Buffer = 0;
3025 SecurityBlob->UserName.Length = 0;
3026 SecurityBlob->UserName.MaximumLength = 0;
3028 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3031 SecurityBlob->UserName.MaximumLength =
3033 SecurityBlob->UserName.Buffer =
3034 cpu_to_le32(SecurityBlobLength);
3036 SecurityBlobLength += ln;
3037 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3040 /* SecurityBlob->WorkstationName.Length =
3041 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3042 SecurityBlob->WorkstationName.Length *= 2;
3043 SecurityBlob->WorkstationName.MaximumLength =
3044 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3045 SecurityBlob->WorkstationName.Buffer =
3046 cpu_to_le32(SecurityBlobLength);
3047 bcc_ptr += SecurityBlob->WorkstationName.Length;
3048 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3049 SecurityBlob->WorkstationName.Length =
3050 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3052 if ((long) bcc_ptr % 2) {
3057 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3059 bcc_ptr += 2 * bytes_returned;
3061 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3063 bcc_ptr += 2 * bytes_returned;
3064 bcc_ptr += 2; /* null term version string */
3066 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3068 bcc_ptr += 2 * bytes_returned;
3071 bcc_ptr += 2; /* null terminate network opsys string */
3074 bcc_ptr += 2; /* null domain */
3075 } else { /* ASCII */
3076 if (domain == NULL) {
3077 SecurityBlob->DomainName.Buffer = 0;
3078 SecurityBlob->DomainName.Length = 0;
3079 SecurityBlob->DomainName.MaximumLength = 0;
3082 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3083 strncpy(bcc_ptr, domain, 63);
3084 ln = strnlen(domain, 64);
3085 SecurityBlob->DomainName.MaximumLength =
3087 SecurityBlob->DomainName.Buffer =
3088 cpu_to_le32(SecurityBlobLength);
3090 SecurityBlobLength += ln;
3091 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3094 SecurityBlob->UserName.Buffer = 0;
3095 SecurityBlob->UserName.Length = 0;
3096 SecurityBlob->UserName.MaximumLength = 0;
3099 strncpy(bcc_ptr, user, 63);
3100 ln = strnlen(user, 64);
3101 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3102 SecurityBlob->UserName.Buffer =
3103 cpu_to_le32(SecurityBlobLength);
3105 SecurityBlobLength += ln;
3106 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3108 /* BB fill in our workstation name if known BB */
3110 strcpy(bcc_ptr, "Linux version ");
3111 bcc_ptr += strlen("Linux version ");
3112 strcpy(bcc_ptr, utsname()->release);
3113 bcc_ptr += strlen(utsname()->release) + 1;
3114 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3115 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3116 bcc_ptr++; /* null domain */
3119 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3120 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3121 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3122 smb_buffer->smb_buf_length += count;
3123 pSMB->req.ByteCount = cpu_to_le16(count);
3125 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3126 &bytes_returned, CIFS_LONG_OP);
3128 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3129 } else if ((smb_buffer_response->WordCount == 3) ||
3130 (smb_buffer_response->WordCount == 4)) {
3131 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3132 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3133 if (action & GUEST_LOGIN)
3134 cFYI(1, (" Guest login")); /* BB Should we set anything
3135 in SesInfo struct ? */
3136 /* if (SecurityBlob2->MessageType != NtLm??) {
3137 cFYI("Unexpected message type on auth response is %d"));
3142 ("Check challenge UID %d vs auth response UID %d",
3143 ses->Suid, smb_buffer_response->Uid));
3144 /* UID left in wire format */
3145 ses->Suid = smb_buffer_response->Uid;
3146 bcc_ptr = pByteArea(smb_buffer_response);
3147 /* response can have either 3 or 4 word count - Samba sends 3 */
3148 if ((pSMBr->resp.hdr.WordCount == 3)
3149 || ((pSMBr->resp.hdr.WordCount == 4)
3151 pSMBr->resp.ByteCount))) {
3152 if (pSMBr->resp.hdr.WordCount == 4) {
3156 ("Security Blob Length %d ",
3161 ("NTLMSSP response to Authenticate "));
3163 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3164 if ((long) (bcc_ptr) % 2) {
3166 (BCC(smb_buffer_response)
3168 bcc_ptr++; /* Unicode strings must be word aligned */
3170 remaining_words = BCC(smb_buffer_response) / 2;
3172 len = UniStrnlen((wchar_t *) bcc_ptr,
3173 remaining_words - 1);
3174 /* We look for obvious messed up bcc or strings in response so we do not go off
3175 the end since (at least) WIN2K and Windows XP have a major bug in not null
3176 terminating last Unicode string in response */
3178 kfree(ses->serverOS);
3180 kzalloc(2 * (len + 1), GFP_KERNEL);
3181 cifs_strfromUCS_le(ses->serverOS,
3185 bcc_ptr += 2 * (len + 1);
3186 remaining_words -= len + 1;
3187 ses->serverOS[2 * len] = 0;
3188 ses->serverOS[1 + (2 * len)] = 0;
3189 if (remaining_words > 0) {
3190 len = UniStrnlen((wchar_t *)
3194 kfree(ses->serverNOS);
3196 kzalloc(2 * (len + 1),
3198 cifs_strfromUCS_le(ses->
3204 bcc_ptr += 2 * (len + 1);
3205 ses->serverNOS[2 * len] = 0;
3206 ses->serverNOS[1+(2*len)] = 0;
3207 remaining_words -= len + 1;
3208 if (remaining_words > 0) {
3209 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3210 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3211 if (ses->serverDomain)
3212 kfree(ses->serverDomain);
3237 } /* else no more room so create dummy domain string */
3239 if (ses->serverDomain)
3240 kfree(ses->serverDomain);
3241 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3243 } else { /* no room so create dummy domain and NOS string */
3244 if (ses->serverDomain)
3245 kfree(ses->serverDomain);
3246 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3247 kfree(ses->serverNOS);
3248 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3250 } else { /* ASCII */
3251 len = strnlen(bcc_ptr, 1024);
3252 if (((long) bcc_ptr + len) -
3253 (long) pByteArea(smb_buffer_response)
3254 <= BCC(smb_buffer_response)) {
3256 kfree(ses->serverOS);
3257 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3258 strncpy(ses->serverOS,bcc_ptr, len);
3261 bcc_ptr[0] = 0; /* null terminate the string */
3264 len = strnlen(bcc_ptr, 1024);
3265 kfree(ses->serverNOS);
3266 ses->serverNOS = kzalloc(len+1,
3268 strncpy(ses->serverNOS,
3274 len = strnlen(bcc_ptr, 1024);
3275 if (ses->serverDomain)
3276 kfree(ses->serverDomain);
3280 strncpy(ses->serverDomain,
3286 cFYI(1, ("field of length %d "
3287 "extends beyond end of smb ",
3291 cERROR(1, ("Security Blob extends beyond end "
3295 cERROR(1, ("No session structure passed in."));
3298 cERROR(1, ("Invalid Word count %d: ",
3299 smb_buffer_response->WordCount));
3303 cifs_buf_release(smb_buffer);
3309 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3310 const char *tree, struct cifsTconInfo *tcon,
3311 const struct nls_table *nls_codepage)
3313 struct smb_hdr *smb_buffer;
3314 struct smb_hdr *smb_buffer_response;
3317 unsigned char *bcc_ptr;
3325 smb_buffer = cifs_buf_get();
3326 if (smb_buffer == NULL) {
3329 smb_buffer_response = smb_buffer;
3331 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3332 NULL /*no tid */ , 4 /*wct */ );
3334 smb_buffer->Mid = GetNextMid(ses->server);
3335 smb_buffer->Uid = ses->Suid;
3336 pSMB = (TCONX_REQ *) smb_buffer;
3337 pSMBr = (TCONX_RSP *) smb_buffer_response;
3339 pSMB->AndXCommand = 0xFF;
3340 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3341 bcc_ptr = &pSMB->Password[0];
3342 if ((ses->server->secMode) & SECMODE_USER) {
3343 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3344 *bcc_ptr = 0; /* password is null byte */
3345 bcc_ptr++; /* skip password */
3346 /* already aligned so no need to do it below */
3348 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3349 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3350 specified as required (when that support is added to
3351 the vfs in the future) as only NTLM or the much
3352 weaker LANMAN (which we do not send by default) is accepted
3353 by Samba (not sure whether other servers allow
3354 NTLMv2 password here) */
3355 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3356 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3357 (ses->server->secType == LANMAN))
3358 calc_lanman_hash(ses, bcc_ptr);
3360 #endif /* CIFS_WEAK_PW_HASH */
3361 SMBNTencrypt(ses->password,
3362 ses->server->cryptKey,
3365 bcc_ptr += CIFS_SESS_KEY_SIZE;
3366 if (ses->capabilities & CAP_UNICODE) {
3367 /* must align unicode strings */
3368 *bcc_ptr = 0; /* null byte password */
3373 if (ses->server->secMode &
3374 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3375 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3377 if (ses->capabilities & CAP_STATUS32) {
3378 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3380 if (ses->capabilities & CAP_DFS) {
3381 smb_buffer->Flags2 |= SMBFLG2_DFS;
3383 if (ses->capabilities & CAP_UNICODE) {
3384 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3386 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3387 6 /* max utf8 char length in bytes */ *
3388 (/* server len*/ + 256 /* share len */), nls_codepage);
3389 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3390 bcc_ptr += 2; /* skip trailing null */
3391 } else { /* ASCII */
3392 strcpy(bcc_ptr, tree);
3393 bcc_ptr += strlen(tree) + 1;
3395 strcpy(bcc_ptr, "?????");
3396 bcc_ptr += strlen("?????");
3398 count = bcc_ptr - &pSMB->Password[0];
3399 pSMB->hdr.smb_buf_length += count;
3400 pSMB->ByteCount = cpu_to_le16(count);
3402 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3405 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3406 /* above now done in SendReceive */
3407 if ((rc == 0) && (tcon != NULL)) {
3408 tcon->tidStatus = CifsGood;
3409 tcon->tid = smb_buffer_response->Tid;
3410 bcc_ptr = pByteArea(smb_buffer_response);
3411 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3412 /* skip service field (NB: this field is always ASCII) */
3414 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3415 (bcc_ptr[2] == 'C')) {
3416 cFYI(1, ("IPC connection"));
3419 } else if (length == 2) {
3420 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3421 /* the most common case */
3422 cFYI(1, ("disk share connection"));
3425 bcc_ptr += length + 1;
3426 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3427 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3428 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3429 if ((bcc_ptr + (2 * length)) -
3430 pByteArea(smb_buffer_response) <=
3431 BCC(smb_buffer_response)) {
3432 kfree(tcon->nativeFileSystem);
3433 tcon->nativeFileSystem =
3434 kzalloc(length + 2, GFP_KERNEL);
3435 if (tcon->nativeFileSystem)
3437 tcon->nativeFileSystem,
3439 length, nls_codepage);
3440 bcc_ptr += 2 * length;
3441 bcc_ptr[0] = 0; /* null terminate the string */
3445 /* else do not bother copying these information fields*/
3447 length = strnlen(bcc_ptr, 1024);
3448 if ((bcc_ptr + length) -
3449 pByteArea(smb_buffer_response) <=
3450 BCC(smb_buffer_response)) {
3451 kfree(tcon->nativeFileSystem);
3452 tcon->nativeFileSystem =
3453 kzalloc(length + 1, GFP_KERNEL);
3454 if (tcon->nativeFileSystem)
3455 strncpy(tcon->nativeFileSystem, bcc_ptr,
3458 /* else do not bother copying these information fields*/
3460 if ((smb_buffer_response->WordCount == 3) ||
3461 (smb_buffer_response->WordCount == 7))
3462 /* field is in same location */
3463 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3466 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3467 } else if ((rc == 0) && tcon == NULL) {
3468 /* all we need to save for IPC$ connection */
3469 ses->ipc_tid = smb_buffer_response->Tid;
3472 cifs_buf_release(smb_buffer);
3477 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3481 struct cifsSesInfo *ses = NULL;
3482 struct task_struct *cifsd_task;
3487 if (cifs_sb->tcon) {
3488 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3489 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3494 tconInfoFree(cifs_sb->tcon);
3495 if ((ses) && (ses->server)) {
3496 /* save off task so we do not refer to ses later */
3497 cifsd_task = ses->server->tsk;
3498 cFYI(1, ("About to do SMBLogoff "));
3499 rc = CIFSSMBLogoff(xid, ses);
3503 } else if (rc == -ESHUTDOWN) {
3504 cFYI(1, ("Waking up socket by sending signal"));
3506 force_sig(SIGKILL, cifsd_task);
3507 kthread_stop(cifsd_task);
3510 } /* else - we have an smb session
3511 left on this socket do not kill cifsd */
3513 cFYI(1, ("No session or bad tcon"));
3516 cifs_sb->tcon = NULL;
3517 tmp = cifs_sb->prepath;
3518 cifs_sb->prepathlen = 0;
3519 cifs_sb->prepath = NULL;
3522 schedule_timeout_interruptible(msecs_to_jiffies(500));
3530 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3531 struct nls_table *nls_info)
3534 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3535 int ntlmv2_flag = FALSE;
3538 /* what if server changes its buffer size after dropping the session? */
3539 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3540 rc = CIFSSMBNegotiate(xid, pSesInfo);
3541 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3542 rc = CIFSSMBNegotiate(xid, pSesInfo);
3547 spin_lock(&GlobalMid_Lock);
3548 if (pSesInfo->server->tcpStatus != CifsExiting)
3549 pSesInfo->server->tcpStatus = CifsGood;
3552 spin_unlock(&GlobalMid_Lock);
3558 pSesInfo->flags = 0;
3559 pSesInfo->capabilities = pSesInfo->server->capabilities;
3560 if (linuxExtEnabled == 0)
3561 pSesInfo->capabilities &= (~CAP_UNIX);
3562 /* pSesInfo->sequence_number = 0;*/
3564 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3565 pSesInfo->server->secMode,
3566 pSesInfo->server->capabilities,
3567 pSesInfo->server->timeAdj));
3568 if (experimEnabled < 2)
3569 rc = CIFS_SessSetup(xid, pSesInfo,
3570 first_time, nls_info);
3571 else if (extended_security
3572 && (pSesInfo->capabilities
3573 & CAP_EXTENDED_SECURITY)
3574 && (pSesInfo->server->secType == NTLMSSP)) {
3576 } else if (extended_security
3577 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3578 && (pSesInfo->server->secType == RawNTLMSSP)) {
3579 cFYI(1, ("NTLMSSP sesssetup"));
3580 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3587 cFYI(1, ("more secure NTLM ver2 hash"));
3588 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3593 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3595 CalcNTLMv2_response(pSesInfo,
3598 cifs_calculate_ntlmv2_mac_key(
3599 pSesInfo->server->mac_signing_key,
3600 response, ntlm_session_key,*/
3602 /* BB Put dummy sig in SessSetup PDU? */
3609 SMBNTencrypt(pSesInfo->password,
3610 pSesInfo->server->cryptKey,
3614 cifs_calculate_mac_key(
3615 &pSesInfo->server->mac_signing_key,
3617 pSesInfo->password);
3619 /* for better security the weaker lanman hash not sent
3620 in AuthSessSetup so we no longer calculate it */
3622 rc = CIFSNTLMSSPAuthSessSetup(xid,
3628 } else { /* old style NTLM 0.12 session setup */
3629 SMBNTencrypt(pSesInfo->password,
3630 pSesInfo->server->cryptKey,
3634 cifs_calculate_mac_key(
3635 &pSesInfo->server->mac_signing_key,
3636 ntlm_session_key, pSesInfo->password);
3638 rc = CIFSSessSetup(xid, pSesInfo,
3639 ntlm_session_key, nls_info);
3642 cERROR(1, ("Send error in SessSetup = %d", rc));
3644 cFYI(1, ("CIFS Session Established successfully"));
3645 pSesInfo->status = CifsGood;