4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 extern mempool_t *cifs_req_poolp;
63 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
64 char *iocharset; /* local code page for mapping to and from Unicode */
65 char source_rfc1001_name[16]; /* netbios name of client */
66 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
80 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
83 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool remap:1; /* set to remap seven reserved chars in filenames */
86 bool posix_paths:1; /* unset to not ask for posix pathnames. */
89 bool nullauth:1; /* attempt to authenticate with null user */
90 bool nocase:1; /* request case insensitive filenames */
91 bool nobrl:1; /* disable sending byte range locks to srv */
92 bool seal:1; /* request transport encryption on share */
96 unsigned short int port;
100 static int ipv4_connect(struct sockaddr_in *psin_server,
101 struct socket **csocket,
103 char *server_netb_name);
104 static int ipv6_connect(struct sockaddr_in6 *psin_server,
105 struct socket **csocket);
109 * cifs tcp session reconnection
111 * mark tcp session as reconnecting so temporarily locked
112 * mark all smb sessions as reconnecting for tcp session
113 * reconnect tcp session
114 * wake up waiters on reconnection? - (not needed currently)
118 cifs_reconnect(struct TCP_Server_Info *server)
121 struct list_head *tmp;
122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
124 struct mid_q_entry *mid_entry;
126 spin_lock(&GlobalMid_Lock);
127 if (kthread_should_stop()) {
128 /* the demux thread will exit normally
129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
137 cFYI(1, ("Reconnecting tcp session"));
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
141 read_lock(&GlobalSMBSeslock);
142 list_for_each(tmp, &GlobalSMBSessionList) {
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
145 if (ses->server == server) {
146 ses->status = CifsNeedReconnect;
150 /* else tcp and smb sessions need reconnection */
152 list_for_each(tmp, &GlobalTreeConnectionList) {
153 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
154 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
155 tcon->tidStatus = CifsNeedReconnect;
157 read_unlock(&GlobalSMBSeslock);
158 /* do not want to be sending data on a socket we are freeing */
159 down(&server->tcpSem);
160 if (server->ssocket) {
161 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
162 server->ssocket->flags));
163 kernel_sock_shutdown(server->ssocket, SHUT_WR);
164 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
165 server->ssocket->state,
166 server->ssocket->flags));
167 sock_release(server->ssocket);
168 server->ssocket = NULL;
171 spin_lock(&GlobalMid_Lock);
172 list_for_each(tmp, &server->pending_mid_q) {
173 mid_entry = list_entry(tmp, struct
177 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
178 /* Mark other intransit requests as needing
179 retry so we do not immediately mark the
180 session bad again (ie after we reconnect
181 below) as they timeout too */
182 mid_entry->midState = MID_RETRY_NEEDED;
186 spin_unlock(&GlobalMid_Lock);
189 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
191 if (server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,
195 rc = ipv4_connect(&server->addr.sockAddr,
197 server->workstation_RFC1001_name,
198 server->server_RFC1001_name);
201 cFYI(1, ("reconnect error %d", rc));
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
206 if (!kthread_should_stop())
207 server->tcpStatus = CifsGood;
208 server->sequence_number = 0;
209 spin_unlock(&GlobalMid_Lock);
210 /* atomic_set(&server->inFlight,0);*/
211 wake_up(&server->response_q);
219 0 not a transact2, or all data present
220 >0 transact2 with that much data missing
221 -EINVAL = invalid transact2
224 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
226 struct smb_t2_rsp *pSMBt;
228 int data_in_this_rsp;
231 if (pSMB->Command != SMB_COM_TRANSACTION2)
234 /* check for plausible wct, bcc and t2 data and parm sizes */
235 /* check for parm and data offset going beyond end of smb */
236 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
237 cFYI(1, ("invalid transact2 word count"));
241 pSMBt = (struct smb_t2_rsp *)pSMB;
243 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
244 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
246 remaining = total_data_size - data_in_this_rsp;
250 else if (remaining < 0) {
251 cFYI(1, ("total data %d smaller than data in frame %d",
252 total_data_size, data_in_this_rsp));
255 cFYI(1, ("missing %d bytes from transact2, check next response",
257 if (total_data_size > maxBufSize) {
258 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
259 total_data_size, maxBufSize));
266 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
268 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
269 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
274 char *data_area_of_target;
275 char *data_area_of_buf2;
278 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
280 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
281 cFYI(1, ("total data size of primary and secondary t2 differ"));
284 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
286 remaining = total_data_size - total_in_buf;
291 if (remaining == 0) /* nothing to do, ignore */
294 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
295 if (remaining < total_in_buf2) {
296 cFYI(1, ("transact2 2nd response contains too much data"));
299 /* find end of first SMB data area */
300 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
301 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
302 /* validate target area */
304 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
305 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
307 data_area_of_target += total_in_buf;
309 /* copy second buffer into end of first buffer */
310 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
311 total_in_buf += total_in_buf2;
312 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
313 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
314 byte_count += total_in_buf2;
315 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
317 byte_count = pTargetSMB->smb_buf_length;
318 byte_count += total_in_buf2;
320 /* BB also add check that we are not beyond maximum buffer size */
322 pTargetSMB->smb_buf_length = byte_count;
324 if (remaining == total_in_buf2) {
325 cFYI(1, ("found the last secondary response"));
326 return 0; /* we are done */
327 } else /* more responses to go */
333 cifs_demultiplex_thread(struct TCP_Server_Info *server)
336 unsigned int pdu_length, total_read;
337 struct smb_hdr *smb_buffer = NULL;
338 struct smb_hdr *bigbuf = NULL;
339 struct smb_hdr *smallbuf = NULL;
340 struct msghdr smb_msg;
342 struct socket *csocket = server->ssocket;
343 struct list_head *tmp;
344 struct cifsSesInfo *ses;
345 struct task_struct *task_to_wake = NULL;
346 struct mid_q_entry *mid_entry;
348 bool isLargeBuf = false;
352 current->flags |= PF_MEMALLOC;
353 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
355 length = atomic_inc_return(&tcpSesAllocCount);
357 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
361 while (!kthread_should_stop()) {
364 if (bigbuf == NULL) {
365 bigbuf = cifs_buf_get();
367 cERROR(1, ("No memory for large SMB response"));
369 /* retry will check if exiting */
372 } else if (isLargeBuf) {
373 /* we are reusing a dirty large buf, clear its start */
374 memset(bigbuf, 0, sizeof(struct smb_hdr));
377 if (smallbuf == NULL) {
378 smallbuf = cifs_small_buf_get();
380 cERROR(1, ("No memory for SMB response"));
382 /* retry will check if exiting */
385 /* beginning of smb buffer is cleared in our buf_get */
386 } else /* if existing small buf clear beginning */
387 memset(smallbuf, 0, sizeof(struct smb_hdr));
391 smb_buffer = smallbuf;
392 iov.iov_base = smb_buffer;
394 smb_msg.msg_control = NULL;
395 smb_msg.msg_controllen = 0;
396 pdu_length = 4; /* enough to get RFC1001 header */
399 kernel_recvmsg(csocket, &smb_msg,
400 &iov, 1, pdu_length, 0 /* BB other flags? */);
402 if (kthread_should_stop()) {
404 } else if (server->tcpStatus == CifsNeedReconnect) {
405 cFYI(1, ("Reconnect after server stopped responding"));
406 cifs_reconnect(server);
407 cFYI(1, ("call to reconnect done"));
408 csocket = server->ssocket;
410 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
411 msleep(1); /* minimum sleep to prevent looping
412 allowing socket to clear and app threads to set
413 tcpStatus CifsNeedReconnect if server hung */
418 } else if (length <= 0) {
419 if (server->tcpStatus == CifsNew) {
420 cFYI(1, ("tcp session abend after SMBnegprot"));
421 /* some servers kill the TCP session rather than
422 returning an SMB negprot error, in which
423 case reconnecting here is not going to help,
424 and so simply return error to mount */
427 if (!try_to_freeze() && (length == -EINTR)) {
428 cFYI(1, ("cifsd thread killed"));
431 cFYI(1, ("Reconnect after unexpected peek error %d",
433 cifs_reconnect(server);
434 csocket = server->ssocket;
435 wake_up(&server->response_q);
437 } else if (length < pdu_length) {
438 cFYI(1, ("requested %d bytes but only got %d bytes",
439 pdu_length, length));
440 pdu_length -= length;
445 /* The right amount was read from socket - 4 bytes */
446 /* so we can now interpret the length field */
448 /* the first byte big endian of the length field,
449 is actually not part of the length but the type
450 with the most common, zero, as regular data */
451 temp = *((char *) smb_buffer);
453 /* Note that FC 1001 length is big endian on the wire,
454 but we convert it here so it is always manipulated
455 as host byte order */
456 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
457 smb_buffer->smb_buf_length = pdu_length;
459 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
461 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
463 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
464 cFYI(1, ("Good RFC 1002 session rsp"));
466 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
467 /* we get this from Windows 98 instead of
468 an error on SMB negprot response */
469 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
471 if (server->tcpStatus == CifsNew) {
472 /* if nack on negprot (rather than
473 ret of smb negprot error) reconnecting
474 not going to help, ret error to mount */
477 /* give server a second to
478 clean up before reconnect attempt */
480 /* always try 445 first on reconnect
481 since we get NACK on some if we ever
482 connected to port 139 (the NACK is
483 since we do not begin with RFC1001
484 session initialize frame) */
485 server->addr.sockAddr.sin_port =
487 cifs_reconnect(server);
488 csocket = server->ssocket;
489 wake_up(&server->response_q);
492 } else if (temp != (char) 0) {
493 cERROR(1, ("Unknown RFC 1002 frame"));
494 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
496 cifs_reconnect(server);
497 csocket = server->ssocket;
501 /* else we have an SMB response */
502 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
503 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
504 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
505 length, pdu_length+4));
506 cifs_reconnect(server);
507 csocket = server->ssocket;
508 wake_up(&server->response_q);
515 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
517 memcpy(bigbuf, smallbuf, 4);
521 iov.iov_base = 4 + (char *)smb_buffer;
522 iov.iov_len = pdu_length;
523 for (total_read = 0; total_read < pdu_length;
524 total_read += length) {
525 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
526 pdu_length - total_read, 0);
527 if (kthread_should_stop() ||
528 (length == -EINTR)) {
532 } else if (server->tcpStatus == CifsNeedReconnect) {
533 cifs_reconnect(server);
534 csocket = server->ssocket;
535 /* Reconnect wakes up rspns q */
536 /* Now we will reread sock */
539 } else if ((length == -ERESTARTSYS) ||
540 (length == -EAGAIN)) {
541 msleep(1); /* minimum sleep to prevent looping,
542 allowing socket to clear and app
543 threads to set tcpStatus
544 CifsNeedReconnect if server hung*/
547 } else if (length <= 0) {
548 cERROR(1, ("Received no data, expecting %d",
549 pdu_length - total_read));
550 cifs_reconnect(server);
551 csocket = server->ssocket;
558 else if (reconnect == 1)
561 length += 4; /* account for rfc1002 hdr */
564 dump_smb(smb_buffer, length);
565 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
566 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
572 spin_lock(&GlobalMid_Lock);
573 list_for_each(tmp, &server->pending_mid_q) {
574 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
576 if ((mid_entry->mid == smb_buffer->Mid) &&
577 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
578 (mid_entry->command == smb_buffer->Command)) {
579 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
580 /* We have a multipart transact2 resp */
582 if (mid_entry->resp_buf) {
583 /* merge response - fix up 1st*/
584 if (coalesce_t2(smb_buffer,
585 mid_entry->resp_buf)) {
586 mid_entry->multiRsp =
590 /* all parts received */
591 mid_entry->multiEnd =
597 cERROR(1,("1st trans2 resp needs bigbuf"));
598 /* BB maybe we can fix this up, switch
599 to already allocated large buffer? */
601 /* Have first buffer */
602 mid_entry->resp_buf =
604 mid_entry->largeBuf =
611 mid_entry->resp_buf = smb_buffer;
612 mid_entry->largeBuf = isLargeBuf;
614 task_to_wake = mid_entry->tsk;
615 mid_entry->midState = MID_RESPONSE_RECEIVED;
616 #ifdef CONFIG_CIFS_STATS2
617 mid_entry->when_received = jiffies;
619 /* so we do not time out requests to server
620 which is still responding (since server could
621 be busy but not dead) */
622 server->lstrp = jiffies;
626 spin_unlock(&GlobalMid_Lock);
628 /* Was previous buf put in mpx struct for multi-rsp? */
630 /* smb buffer will be freed by user thread */
636 wake_up_process(task_to_wake);
637 } else if (!is_valid_oplock_break(smb_buffer, server) &&
639 cERROR(1, ("No task to wake, unknown frame received! "
640 "NumMids %d", midCount.counter));
641 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
642 sizeof(struct smb_hdr));
643 #ifdef CONFIG_CIFS_DEBUG2
644 cifs_dump_detail(smb_buffer);
645 cifs_dump_mids(server);
646 #endif /* CIFS_DEBUG2 */
649 } /* end while !EXITING */
651 spin_lock(&GlobalMid_Lock);
652 server->tcpStatus = CifsExiting;
653 spin_unlock(&GlobalMid_Lock);
654 wake_up_all(&server->response_q);
656 /* don't exit until kthread_stop is called */
657 set_current_state(TASK_UNINTERRUPTIBLE);
658 while (!kthread_should_stop()) {
660 set_current_state(TASK_UNINTERRUPTIBLE);
662 set_current_state(TASK_RUNNING);
664 /* check if we have blocked requests that need to free */
665 /* Note that cifs_max_pending is normally 50, but
666 can be set at module install time to as little as two */
667 spin_lock(&GlobalMid_Lock);
668 if (atomic_read(&server->inFlight) >= cifs_max_pending)
669 atomic_set(&server->inFlight, cifs_max_pending - 1);
670 /* We do not want to set the max_pending too low or we
671 could end up with the counter going negative */
672 spin_unlock(&GlobalMid_Lock);
673 /* Although there should not be any requests blocked on
674 this queue it can not hurt to be paranoid and try to wake up requests
675 that may haven been blocked when more than 50 at time were on the wire
676 to the same server - they now will see the session is in exit state
677 and get out of SendReceive. */
678 wake_up_all(&server->request_q);
679 /* give those requests time to exit */
682 if (server->ssocket) {
683 sock_release(csocket);
684 server->ssocket = NULL;
686 /* buffer usuallly freed in free_mid - need to free it here on exit */
687 cifs_buf_release(bigbuf);
688 if (smallbuf) /* no sense logging a debug message if NULL */
689 cifs_small_buf_release(smallbuf);
691 read_lock(&GlobalSMBSeslock);
692 if (list_empty(&server->pending_mid_q)) {
693 /* loop through server session structures attached to this and
695 list_for_each(tmp, &GlobalSMBSessionList) {
697 list_entry(tmp, struct cifsSesInfo,
699 if (ses->server == server) {
700 ses->status = CifsExiting;
704 read_unlock(&GlobalSMBSeslock);
706 /* although we can not zero the server struct pointer yet,
707 since there are active requests which may depnd on them,
708 mark the corresponding SMB sessions as exiting too */
709 list_for_each(tmp, &GlobalSMBSessionList) {
710 ses = list_entry(tmp, struct cifsSesInfo,
712 if (ses->server == server)
713 ses->status = CifsExiting;
716 spin_lock(&GlobalMid_Lock);
717 list_for_each(tmp, &server->pending_mid_q) {
718 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
719 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
720 cFYI(1, ("Clearing Mid 0x%x - waking up ",
722 task_to_wake = mid_entry->tsk;
724 wake_up_process(task_to_wake);
727 spin_unlock(&GlobalMid_Lock);
728 read_unlock(&GlobalSMBSeslock);
729 /* 1/8th of sec is more than enough time for them to exit */
733 if (!list_empty(&server->pending_mid_q)) {
734 /* mpx threads have not exited yet give them
735 at least the smb send timeout time for long ops */
736 /* due to delays on oplock break requests, we need
737 to wait at least 45 seconds before giving up
738 on a request getting a response and going ahead
740 cFYI(1, ("Wait for exit from demultiplex thread"));
742 /* if threads still have not exited they are probably never
743 coming home not much else we can do but free the memory */
746 /* last chance to mark ses pointers invalid
747 if there are any pointing to this (e.g
748 if a crazy root user tried to kill cifsd
749 kernel thread explicitly this might happen) */
750 write_lock(&GlobalSMBSeslock);
751 list_for_each(tmp, &GlobalSMBSessionList) {
752 ses = list_entry(tmp, struct cifsSesInfo,
754 if (ses->server == server)
757 write_unlock(&GlobalSMBSeslock);
759 kfree(server->hostname);
762 length = atomic_dec_return(&tcpSesAllocCount);
764 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
770 /* extract the host portion of the UNC string */
772 extract_hostname(const char *unc)
778 /* skip double chars at beginning of string */
779 /* BB: check validity of these bytes? */
782 /* delimiter between hostname and sharename is always '\\' now */
783 delim = strchr(src, '\\');
785 return ERR_PTR(-EINVAL);
788 dst = kmalloc((len + 1), GFP_KERNEL);
790 return ERR_PTR(-ENOMEM);
792 memcpy(dst, src, len);
799 cifs_parse_mount_options(char *options, const char *devname,
804 unsigned int temp_len, i, j;
810 if (Local_System_Name[0] != 0)
811 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
813 char *nodename = utsname()->nodename;
814 int n = strnlen(nodename, 15);
815 memset(vol->source_rfc1001_name, 0x20, 15);
816 for (i = 0; i < n; i++) {
817 /* does not have to be perfect mapping since field is
818 informational, only used for servers that do not support
819 port 445 and it can be overridden at mount time */
820 vol->source_rfc1001_name[i] = toupper(nodename[i]);
823 vol->source_rfc1001_name[15] = 0;
824 /* null target name indicates to use *SMBSERVR default called name
825 if we end up sending RFC1001 session initialize */
826 vol->target_rfc1001_name[0] = 0;
827 vol->linux_uid = current->uid; /* current->euid instead? */
828 vol->linux_gid = current->gid;
829 vol->dir_mode = S_IRWXUGO;
830 /* 2767 perms indicate mandatory locking support */
831 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
833 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
835 /* default is always to request posix paths. */
836 vol->posix_paths = 1;
841 if (strncmp(options, "sep=", 4) == 0) {
842 if (options[4] != 0) {
843 separator[0] = options[4];
846 cFYI(1, ("Null separator not allowed"));
850 while ((data = strsep(&options, separator)) != NULL) {
853 if ((value = strchr(data, '=')) != NULL)
856 /* Have to parse this before we parse for "user" */
857 if (strnicmp(data, "user_xattr", 10) == 0) {
859 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
861 } else if (strnicmp(data, "user", 4) == 0) {
864 "CIFS: invalid or missing username\n");
865 return 1; /* needs_arg; */
866 } else if (!*value) {
867 /* null user, ie anonymous, authentication */
870 if (strnlen(value, 200) < 200) {
871 vol->username = value;
873 printk(KERN_WARNING "CIFS: username too long\n");
876 } else if (strnicmp(data, "pass", 4) == 0) {
878 vol->password = NULL;
880 } else if (value[0] == 0) {
881 /* check if string begins with double comma
882 since that would mean the password really
883 does start with a comma, and would not
884 indicate an empty string */
885 if (value[1] != separator[0]) {
886 vol->password = NULL;
890 temp_len = strlen(value);
891 /* removed password length check, NTLM passwords
892 can be arbitrarily long */
894 /* if comma in password, the string will be
895 prematurely null terminated. Commas in password are
896 specified across the cifs mount interface by a double
897 comma ie ,, and a comma used as in other cases ie ','
898 as a parameter delimiter/separator is single and due
899 to the strsep above is temporarily zeroed. */
901 /* NB: password legally can have multiple commas and
902 the only illegal character in a password is null */
904 if ((value[temp_len] == 0) &&
905 (value[temp_len+1] == separator[0])) {
907 value[temp_len] = separator[0];
908 temp_len += 2; /* move after second comma */
909 while (value[temp_len] != 0) {
910 if (value[temp_len] == separator[0]) {
911 if (value[temp_len+1] ==
913 /* skip second comma */
916 /* single comma indicating start
923 if (value[temp_len] == 0) {
927 /* point option to start of next parm */
928 options = value + temp_len + 1;
930 /* go from value to value + temp_len condensing
931 double commas to singles. Note that this ends up
932 allocating a few bytes too many, which is ok */
933 vol->password = kzalloc(temp_len, GFP_KERNEL);
934 if (vol->password == NULL) {
935 printk(KERN_WARNING "CIFS: no memory "
939 for (i = 0, j = 0; i < temp_len; i++, j++) {
940 vol->password[j] = value[i];
941 if (value[i] == separator[0]
942 && value[i+1] == separator[0]) {
943 /* skip second comma */
947 vol->password[j] = 0;
949 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
950 if (vol->password == NULL) {
951 printk(KERN_WARNING "CIFS: no memory "
955 strcpy(vol->password, value);
957 } else if (strnicmp(data, "ip", 2) == 0) {
958 if (!value || !*value) {
960 } else if (strnlen(value, 35) < 35) {
963 printk(KERN_WARNING "CIFS: ip address "
967 } else if (strnicmp(data, "sec", 3) == 0) {
968 if (!value || !*value) {
969 cERROR(1, ("no security value specified"));
971 } else if (strnicmp(value, "krb5i", 5) == 0) {
972 vol->secFlg |= CIFSSEC_MAY_KRB5 |
974 } else if (strnicmp(value, "krb5p", 5) == 0) {
975 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
977 cERROR(1, ("Krb5 cifs privacy not supported"));
979 } else if (strnicmp(value, "krb5", 4) == 0) {
980 vol->secFlg |= CIFSSEC_MAY_KRB5;
981 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
982 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
984 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
985 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
986 } else if (strnicmp(value, "ntlmi", 5) == 0) {
987 vol->secFlg |= CIFSSEC_MAY_NTLM |
989 } else if (strnicmp(value, "ntlm", 4) == 0) {
990 /* ntlm is default so can be turned off too */
991 vol->secFlg |= CIFSSEC_MAY_NTLM;
992 } else if (strnicmp(value, "nontlm", 6) == 0) {
993 /* BB is there a better way to do this? */
994 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
995 #ifdef CONFIG_CIFS_WEAK_PW_HASH
996 } else if (strnicmp(value, "lanman", 6) == 0) {
997 vol->secFlg |= CIFSSEC_MAY_LANMAN;
999 } else if (strnicmp(value, "none", 4) == 0) {
1002 cERROR(1, ("bad security option: %s", value));
1005 } else if ((strnicmp(data, "unc", 3) == 0)
1006 || (strnicmp(data, "target", 6) == 0)
1007 || (strnicmp(data, "path", 4) == 0)) {
1008 if (!value || !*value) {
1009 printk(KERN_WARNING "CIFS: invalid path to "
1010 "network resource\n");
1011 return 1; /* needs_arg; */
1013 if ((temp_len = strnlen(value, 300)) < 300) {
1014 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1015 if (vol->UNC == NULL)
1017 strcpy(vol->UNC, value);
1018 if (strncmp(vol->UNC, "//", 2) == 0) {
1021 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1023 "CIFS: UNC Path does not begin "
1024 "with // or \\\\ \n");
1028 printk(KERN_WARNING "CIFS: UNC name too long\n");
1031 } else if ((strnicmp(data, "domain", 3) == 0)
1032 || (strnicmp(data, "workgroup", 5) == 0)) {
1033 if (!value || !*value) {
1034 printk(KERN_WARNING "CIFS: invalid domain name\n");
1035 return 1; /* needs_arg; */
1037 /* BB are there cases in which a comma can be valid in
1038 a domain name and need special handling? */
1039 if (strnlen(value, 256) < 256) {
1040 vol->domainname = value;
1041 cFYI(1, ("Domain name set"));
1043 printk(KERN_WARNING "CIFS: domain name too "
1047 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1048 if (!value || !*value) {
1050 "CIFS: invalid path prefix\n");
1051 return 1; /* needs_argument */
1053 if ((temp_len = strnlen(value, 1024)) < 1024) {
1054 if (value[0] != '/')
1055 temp_len++; /* missing leading slash */
1056 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1057 if (vol->prepath == NULL)
1059 if (value[0] != '/') {
1060 vol->prepath[0] = '/';
1061 strcpy(vol->prepath+1, value);
1063 strcpy(vol->prepath, value);
1064 cFYI(1, ("prefix path %s", vol->prepath));
1066 printk(KERN_WARNING "CIFS: prefix too long\n");
1069 } else if (strnicmp(data, "iocharset", 9) == 0) {
1070 if (!value || !*value) {
1071 printk(KERN_WARNING "CIFS: invalid iocharset "
1073 return 1; /* needs_arg; */
1075 if (strnlen(value, 65) < 65) {
1076 if (strnicmp(value, "default", 7))
1077 vol->iocharset = value;
1078 /* if iocharset not set then load_nls_default
1079 is used by caller */
1080 cFYI(1, ("iocharset set to %s", value));
1082 printk(KERN_WARNING "CIFS: iocharset name "
1086 } else if (strnicmp(data, "uid", 3) == 0) {
1087 if (value && *value) {
1089 simple_strtoul(value, &value, 0);
1090 vol->override_uid = 1;
1092 } else if (strnicmp(data, "gid", 3) == 0) {
1093 if (value && *value) {
1095 simple_strtoul(value, &value, 0);
1096 vol->override_gid = 1;
1098 } else if (strnicmp(data, "file_mode", 4) == 0) {
1099 if (value && *value) {
1101 simple_strtoul(value, &value, 0);
1103 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1104 if (value && *value) {
1106 simple_strtoul(value, &value, 0);
1108 } else if (strnicmp(data, "dirmode", 4) == 0) {
1109 if (value && *value) {
1111 simple_strtoul(value, &value, 0);
1113 } else if (strnicmp(data, "port", 4) == 0) {
1114 if (value && *value) {
1116 simple_strtoul(value, &value, 0);
1118 } else if (strnicmp(data, "rsize", 5) == 0) {
1119 if (value && *value) {
1121 simple_strtoul(value, &value, 0);
1123 } else if (strnicmp(data, "wsize", 5) == 0) {
1124 if (value && *value) {
1126 simple_strtoul(value, &value, 0);
1128 } else if (strnicmp(data, "sockopt", 5) == 0) {
1129 if (value && *value) {
1131 simple_strtoul(value, &value, 0);
1133 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1134 if (!value || !*value || (*value == ' ')) {
1135 cFYI(1, ("invalid (empty) netbiosname"));
1137 memset(vol->source_rfc1001_name, 0x20, 15);
1138 for (i = 0; i < 15; i++) {
1139 /* BB are there cases in which a comma can be
1140 valid in this workstation netbios name (and need
1141 special handling)? */
1143 /* We do not uppercase netbiosname for user */
1147 vol->source_rfc1001_name[i] =
1150 /* The string has 16th byte zero still from
1151 set at top of the function */
1152 if ((i == 15) && (value[i] != 0))
1153 printk(KERN_WARNING "CIFS: netbiosname"
1154 " longer than 15 truncated.\n");
1156 } else if (strnicmp(data, "servern", 7) == 0) {
1157 /* servernetbiosname specified override *SMBSERVER */
1158 if (!value || !*value || (*value == ' ')) {
1159 cFYI(1, ("empty server netbiosname specified"));
1161 /* last byte, type, is 0x20 for servr type */
1162 memset(vol->target_rfc1001_name, 0x20, 16);
1164 for (i = 0; i < 15; i++) {
1165 /* BB are there cases in which a comma can be
1166 valid in this workstation netbios name
1167 (and need special handling)? */
1169 /* user or mount helper must uppercase
1174 vol->target_rfc1001_name[i] =
1177 /* The string has 16th byte zero still from
1178 set at top of the function */
1179 if ((i == 15) && (value[i] != 0))
1180 printk(KERN_WARNING "CIFS: server net"
1181 "biosname longer than 15 truncated.\n");
1183 } else if (strnicmp(data, "credentials", 4) == 0) {
1185 } else if (strnicmp(data, "version", 3) == 0) {
1187 } else if (strnicmp(data, "guest", 5) == 0) {
1189 } else if (strnicmp(data, "rw", 2) == 0) {
1191 } else if ((strnicmp(data, "suid", 4) == 0) ||
1192 (strnicmp(data, "nosuid", 6) == 0) ||
1193 (strnicmp(data, "exec", 4) == 0) ||
1194 (strnicmp(data, "noexec", 6) == 0) ||
1195 (strnicmp(data, "nodev", 5) == 0) ||
1196 (strnicmp(data, "noauto", 6) == 0) ||
1197 (strnicmp(data, "dev", 3) == 0)) {
1198 /* The mount tool or mount.cifs helper (if present)
1199 uses these opts to set flags, and the flags are read
1200 by the kernel vfs layer before we get here (ie
1201 before read super) so there is no point trying to
1202 parse these options again and set anything and it
1203 is ok to just ignore them */
1205 } else if (strnicmp(data, "ro", 2) == 0) {
1207 } else if (strnicmp(data, "hard", 4) == 0) {
1209 } else if (strnicmp(data, "soft", 4) == 0) {
1211 } else if (strnicmp(data, "perm", 4) == 0) {
1213 } else if (strnicmp(data, "noperm", 6) == 0) {
1215 } else if (strnicmp(data, "mapchars", 8) == 0) {
1217 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1219 } else if (strnicmp(data, "sfu", 3) == 0) {
1221 } else if (strnicmp(data, "nosfu", 5) == 0) {
1223 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1224 vol->posix_paths = 1;
1225 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1226 vol->posix_paths = 0;
1227 } else if (strnicmp(data, "nounix", 6) == 0) {
1228 vol->no_linux_ext = 1;
1229 } else if (strnicmp(data, "nolinux", 7) == 0) {
1230 vol->no_linux_ext = 1;
1231 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1232 (strnicmp(data, "ignorecase", 10) == 0)) {
1234 } else if (strnicmp(data, "brl", 3) == 0) {
1236 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1237 (strnicmp(data, "nolock", 6) == 0)) {
1239 /* turn off mandatory locking in mode
1240 if remote locking is turned off since the
1241 local vfs will do advisory */
1242 if (vol->file_mode ==
1243 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1244 vol->file_mode = S_IALLUGO;
1245 } else if (strnicmp(data, "setuids", 7) == 0) {
1247 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1249 } else if (strnicmp(data, "dynperm", 7) == 0) {
1250 vol->dynperm = true;
1251 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1252 vol->dynperm = false;
1253 } else if (strnicmp(data, "nohard", 6) == 0) {
1255 } else if (strnicmp(data, "nosoft", 6) == 0) {
1257 } else if (strnicmp(data, "nointr", 6) == 0) {
1259 } else if (strnicmp(data, "intr", 4) == 0) {
1261 } else if (strnicmp(data, "serverino", 7) == 0) {
1262 vol->server_ino = 1;
1263 } else if (strnicmp(data, "noserverino", 9) == 0) {
1264 vol->server_ino = 0;
1265 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1267 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1269 } else if (strnicmp(data, "acl", 3) == 0) {
1270 vol->no_psx_acl = 0;
1271 } else if (strnicmp(data, "noacl", 5) == 0) {
1272 vol->no_psx_acl = 1;
1273 } else if (strnicmp(data, "sign", 4) == 0) {
1274 vol->secFlg |= CIFSSEC_MUST_SIGN;
1275 } else if (strnicmp(data, "seal", 4) == 0) {
1276 /* we do not do the following in secFlags because seal
1277 is a per tree connection (mount) not a per socket
1278 or per-smb connection option in the protocol */
1279 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1281 } else if (strnicmp(data, "direct", 6) == 0) {
1283 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1285 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1286 if (!value || !*value) {
1287 vol->in6_addr = NULL;
1288 } else if (strnlen(value, 49) == 48) {
1289 vol->in6_addr = value;
1291 printk(KERN_WARNING "CIFS: ip v6 address not "
1292 "48 characters long\n");
1295 } else if (strnicmp(data, "noac", 4) == 0) {
1296 printk(KERN_WARNING "CIFS: Mount option noac not "
1297 "supported. Instead set "
1298 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1300 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1303 if (vol->UNC == NULL) {
1304 if (devname == NULL) {
1305 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1309 if ((temp_len = strnlen(devname, 300)) < 300) {
1310 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1311 if (vol->UNC == NULL)
1313 strcpy(vol->UNC, devname);
1314 if (strncmp(vol->UNC, "//", 2) == 0) {
1317 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1318 printk(KERN_WARNING "CIFS: UNC Path does not "
1319 "begin with // or \\\\ \n");
1322 value = strpbrk(vol->UNC+2, "/\\");
1326 printk(KERN_WARNING "CIFS: UNC name too long\n");
1330 if (vol->UNCip == NULL)
1331 vol->UNCip = &vol->UNC[2];
1336 static struct cifsSesInfo *
1337 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1338 struct in6_addr *target_ip6_addr,
1339 char *userName, struct TCP_Server_Info **psrvTcp)
1341 struct list_head *tmp;
1342 struct cifsSesInfo *ses;
1346 read_lock(&GlobalSMBSeslock);
1347 list_for_each(tmp, &GlobalSMBSessionList) {
1348 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1352 if (target_ip_addr &&
1353 ses->server->addr.sockAddr.sin_addr.s_addr != target_ip_addr->s_addr)
1355 else if (target_ip6_addr &&
1356 memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1357 target_ip6_addr, sizeof(*target_ip6_addr)))
1359 /* BB lock server and tcp session; increment use count here?? */
1361 /* found a match on the TCP session */
1362 *psrvTcp = ses->server;
1364 /* BB check if reconnection needed */
1365 if (strncmp(ses->userName, userName, MAX_USERNAME_SIZE) == 0) {
1366 read_unlock(&GlobalSMBSeslock);
1367 /* Found exact match on both TCP and
1371 /* else tcp and smb sessions need reconnection */
1373 read_unlock(&GlobalSMBSeslock);
1378 static struct cifsTconInfo *
1379 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1381 struct list_head *tmp;
1382 struct cifsTconInfo *tcon;
1385 read_lock(&GlobalSMBSeslock);
1387 list_for_each(tmp, &GlobalTreeConnectionList) {
1388 cFYI(1, ("Next tcon"));
1389 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1390 if (!tcon->ses || !tcon->ses->server)
1393 old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
1394 cFYI(1, ("old ip addr: %x == new ip %x ?",
1395 old_ip, new_target_ip_addr));
1397 if (old_ip != new_target_ip_addr)
1400 /* BB lock tcon, server, tcp session and increment use count? */
1401 /* found a match on the TCP session */
1402 /* BB check if reconnection needed */
1403 cFYI(1, ("IP match, old UNC: %s new: %s",
1404 tcon->treeName, uncName));
1406 if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
1409 cFYI(1, ("and old usr: %s new: %s",
1410 tcon->treeName, uncName));
1412 if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
1415 /* matched smb session (user name) */
1416 read_unlock(&GlobalSMBSeslock);
1420 read_unlock(&GlobalSMBSeslock);
1425 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1426 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1427 struct dfs_info3_param **preferrals, int remap)
1432 *pnum_referrals = 0;
1435 if (pSesInfo->ipc_tid == 0) {
1436 temp_unc = kmalloc(2 /* for slashes */ +
1437 strnlen(pSesInfo->serverName,
1438 SERVER_NAME_LEN_WITH_NULL * 2)
1439 + 1 + 4 /* slash IPC$ */ + 2,
1441 if (temp_unc == NULL)
1445 strcpy(temp_unc + 2, pSesInfo->serverName);
1446 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1447 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1449 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1453 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1454 pnum_referrals, nls_codepage, remap);
1455 /* BB map targetUNCs to dfs_info3 structures, here or
1456 in CIFSGetDFSRefer BB */
1461 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1462 static struct lock_class_key cifs_key[2];
1463 static struct lock_class_key cifs_slock_key[2];
1466 cifs_reclassify_socket4(struct socket *sock)
1468 struct sock *sk = sock->sk;
1469 BUG_ON(sock_owned_by_user(sk));
1470 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1471 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1475 cifs_reclassify_socket6(struct socket *sock)
1477 struct sock *sk = sock->sk;
1478 BUG_ON(sock_owned_by_user(sk));
1479 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1480 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1484 cifs_reclassify_socket4(struct socket *sock)
1489 cifs_reclassify_socket6(struct socket *sock)
1494 /* See RFC1001 section 14 on representation of Netbios names */
1495 static void rfc1002mangle(char *target, char *source, unsigned int length)
1499 for (i = 0, j = 0; i < (length); i++) {
1500 /* mask a nibble at a time and encode */
1501 target[j] = 'A' + (0x0F & (source[i] >> 4));
1502 target[j+1] = 'A' + (0x0F & source[i]);
1510 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1511 char *netbios_name, char *target_name)
1515 __be16 orig_port = 0;
1517 if (*csocket == NULL) {
1518 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1519 IPPROTO_TCP, csocket);
1521 cERROR(1, ("Error %d creating socket", rc));
1525 /* BB other socket options to set KEEPALIVE, NODELAY? */
1526 cFYI(1, ("Socket created"));
1527 (*csocket)->sk->sk_allocation = GFP_NOFS;
1528 cifs_reclassify_socket4(*csocket);
1532 psin_server->sin_family = AF_INET;
1533 if (psin_server->sin_port) { /* user overrode default port */
1534 rc = (*csocket)->ops->connect(*csocket,
1535 (struct sockaddr *) psin_server,
1536 sizeof(struct sockaddr_in), 0);
1542 /* save original port so we can retry user specified port
1543 later if fall back ports fail this time */
1544 orig_port = psin_server->sin_port;
1546 /* do not retry on the same port we just failed on */
1547 if (psin_server->sin_port != htons(CIFS_PORT)) {
1548 psin_server->sin_port = htons(CIFS_PORT);
1550 rc = (*csocket)->ops->connect(*csocket,
1551 (struct sockaddr *) psin_server,
1552 sizeof(struct sockaddr_in), 0);
1558 psin_server->sin_port = htons(RFC1001_PORT);
1559 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1561 sizeof(struct sockaddr_in), 0);
1566 /* give up here - unless we want to retry on different
1567 protocol families some day */
1570 psin_server->sin_port = orig_port;
1571 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1572 sock_release(*csocket);
1576 /* Eventually check for other socket options to change from
1577 the default. sock_setsockopt not used because it expects
1578 user space buffer */
1579 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1580 (*csocket)->sk->sk_sndbuf,
1581 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1582 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1583 /* make the bufsizes depend on wsize/rsize and max requests */
1584 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1585 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1586 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1587 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1589 /* send RFC1001 sessinit */
1590 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1591 /* some servers require RFC1001 sessinit before sending
1592 negprot - BB check reconnection in case where second
1593 sessinit is sent but no second negprot */
1594 struct rfc1002_session_packet *ses_init_buf;
1595 struct smb_hdr *smb_buf;
1596 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1599 ses_init_buf->trailer.session_req.called_len = 32;
1600 if (target_name && (target_name[0] != 0)) {
1601 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1604 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1605 DEFAULT_CIFS_CALLED_NAME, 16);
1608 ses_init_buf->trailer.session_req.calling_len = 32;
1609 /* calling name ends in null (byte 16) from old smb
1611 if (netbios_name && (netbios_name[0] != 0)) {
1612 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1615 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1616 "LINUX_CIFS_CLNT", 16);
1618 ses_init_buf->trailer.session_req.scope1 = 0;
1619 ses_init_buf->trailer.session_req.scope2 = 0;
1620 smb_buf = (struct smb_hdr *)ses_init_buf;
1621 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1622 smb_buf->smb_buf_length = 0x81000044;
1623 rc = smb_send(*csocket, smb_buf, 0x44,
1624 (struct sockaddr *)psin_server);
1625 kfree(ses_init_buf);
1626 msleep(1); /* RFC1001 layer in at least one server
1627 requires very short break before negprot
1628 presumably because not expecting negprot
1629 to follow so fast. This is a simple
1630 solution that works without
1631 complicating the code and causes no
1632 significant slowing down on mount
1633 for everyone else */
1635 /* else the negprot may still work without this
1636 even though malloc failed */
1644 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1648 __be16 orig_port = 0;
1650 if (*csocket == NULL) {
1651 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1652 IPPROTO_TCP, csocket);
1654 cERROR(1, ("Error %d creating ipv6 socket", rc));
1658 /* BB other socket options to set KEEPALIVE, NODELAY? */
1659 cFYI(1, ("ipv6 Socket created"));
1660 (*csocket)->sk->sk_allocation = GFP_NOFS;
1661 cifs_reclassify_socket6(*csocket);
1665 psin_server->sin6_family = AF_INET6;
1667 if (psin_server->sin6_port) { /* user overrode default port */
1668 rc = (*csocket)->ops->connect(*csocket,
1669 (struct sockaddr *) psin_server,
1670 sizeof(struct sockaddr_in6), 0);
1676 /* save original port so we can retry user specified port
1677 later if fall back ports fail this time */
1679 orig_port = psin_server->sin6_port;
1680 /* do not retry on the same port we just failed on */
1681 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1682 psin_server->sin6_port = htons(CIFS_PORT);
1684 rc = (*csocket)->ops->connect(*csocket,
1685 (struct sockaddr *) psin_server,
1686 sizeof(struct sockaddr_in6), 0);
1692 psin_server->sin6_port = htons(RFC1001_PORT);
1693 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1694 psin_server, sizeof(struct sockaddr_in6), 0);
1699 /* give up here - unless we want to retry on different
1700 protocol families some day */
1703 psin_server->sin6_port = orig_port;
1704 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1705 sock_release(*csocket);
1709 /* Eventually check for other socket options to change from
1710 the default. sock_setsockopt not used because it expects
1711 user space buffer */
1712 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1717 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1718 struct super_block *sb, struct smb_vol *vol_info)
1720 /* if we are reconnecting then should we check to see if
1721 * any requested capabilities changed locally e.g. via
1722 * remount but we can not do much about it here
1723 * if they have (even if we could detect it by the following)
1724 * Perhaps we could add a backpointer to array of sb from tcon
1725 * or if we change to make all sb to same share the same
1726 * sb as NFS - then we only have one backpointer to sb.
1727 * What if we wanted to mount the server share twice once with
1728 * and once without posixacls or posix paths? */
1729 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1731 if (vol_info && vol_info->no_linux_ext) {
1732 tcon->fsUnixInfo.Capability = 0;
1733 tcon->unix_ext = 0; /* Unix Extensions disabled */
1734 cFYI(1, ("Linux protocol extensions disabled"));
1736 } else if (vol_info)
1737 tcon->unix_ext = 1; /* Unix Extensions supported */
1739 if (tcon->unix_ext == 0) {
1740 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1744 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1745 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1747 /* check for reconnect case in which we do not
1748 want to change the mount behavior if we can avoid it */
1749 if (vol_info == NULL) {
1750 /* turn off POSIX ACL and PATHNAMES if not set
1751 originally at mount time */
1752 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1753 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1754 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1755 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1756 cERROR(1, ("POSIXPATH support change"));
1757 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1758 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1759 cERROR(1, ("possible reconnect error"));
1761 ("server disabled POSIX path support"));
1765 cap &= CIFS_UNIX_CAP_MASK;
1766 if (vol_info && vol_info->no_psx_acl)
1767 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1768 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1769 cFYI(1, ("negotiated posix acl support"));
1771 sb->s_flags |= MS_POSIXACL;
1774 if (vol_info && vol_info->posix_paths == 0)
1775 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1776 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1777 cFYI(1, ("negotiate posix pathnames"));
1779 CIFS_SB(sb)->mnt_cifs_flags |=
1780 CIFS_MOUNT_POSIX_PATHS;
1783 /* We might be setting the path sep back to a different
1784 form if we are reconnecting and the server switched its
1785 posix path capability for this share */
1786 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1787 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1789 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1790 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1791 CIFS_SB(sb)->rsize = 127 * 1024;
1793 ("larger reads not supported by srv"));
1798 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1799 #ifdef CONFIG_CIFS_DEBUG2
1800 if (cap & CIFS_UNIX_FCNTL_CAP)
1801 cFYI(1, ("FCNTL cap"));
1802 if (cap & CIFS_UNIX_EXTATTR_CAP)
1803 cFYI(1, ("EXTATTR cap"));
1804 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1805 cFYI(1, ("POSIX path cap"));
1806 if (cap & CIFS_UNIX_XATTR_CAP)
1807 cFYI(1, ("XATTR cap"));
1808 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1809 cFYI(1, ("POSIX ACL cap"));
1810 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1811 cFYI(1, ("very large read cap"));
1812 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1813 cFYI(1, ("very large write cap"));
1814 #endif /* CIFS_DEBUG2 */
1815 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1816 if (vol_info == NULL) {
1817 cFYI(1, ("resetting capabilities failed"));
1819 cERROR(1, ("Negotiating Unix capabilities "
1820 "with the server failed. Consider "
1821 "mounting with the Unix Extensions\n"
1822 "disabled, if problems are found, "
1823 "by specifying the nounix mount "
1831 convert_delimiter(char *path, char delim)
1844 for (i = 0; path[i] != '\0'; i++) {
1845 if (path[i] == old_delim)
1851 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1852 char *mount_data, const char *devname)
1856 int address_type = AF_INET;
1857 struct socket *csocket = NULL;
1858 struct sockaddr_in sin_server;
1859 struct sockaddr_in6 sin_server6;
1860 struct smb_vol volume_info;
1861 struct cifsSesInfo *pSesInfo = NULL;
1862 struct cifsSesInfo *existingCifsSes = NULL;
1863 struct cifsTconInfo *tcon = NULL;
1864 struct TCP_Server_Info *srvTcp = NULL;
1868 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1870 memset(&volume_info, 0, sizeof(struct smb_vol));
1871 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1876 if (volume_info.nullauth) {
1877 cFYI(1, ("null user"));
1878 volume_info.username = "";
1879 } else if (volume_info.username) {
1880 /* BB fixme parse for domain name here */
1881 cFYI(1, ("Username: %s", volume_info.username));
1883 cifserror("No username specified");
1884 /* In userspace mount helper we can get user name from alternate
1885 locations such as env variables and files on disk */
1890 if (volume_info.UNCip && volume_info.UNC) {
1891 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1892 &sin_server.sin_addr.s_addr);
1895 /* not ipv4 address, try ipv6 */
1896 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1897 &sin_server6.sin6_addr.in6_u);
1899 address_type = AF_INET6;
1901 address_type = AF_INET;
1905 /* we failed translating address */
1910 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1913 } else if (volume_info.UNCip) {
1914 /* BB using ip addr as server name to connect to the
1916 cERROR(1, ("Connecting to DFS root not implemented yet"));
1919 } else /* which servers DFS root would we conect to */ {
1921 ("CIFS mount error: No UNC path (e.g. -o "
1922 "unc=//192.168.1.100/public) specified"));
1927 /* this is needed for ASCII cp to Unicode converts */
1928 if (volume_info.iocharset == NULL) {
1929 cifs_sb->local_nls = load_nls_default();
1930 /* load_nls_default can not return null */
1932 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1933 if (cifs_sb->local_nls == NULL) {
1934 cERROR(1, ("CIFS mount error: iocharset %s not found",
1935 volume_info.iocharset));
1941 if (address_type == AF_INET)
1942 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1943 NULL /* no ipv6 addr */,
1944 volume_info.username, &srvTcp);
1945 else if (address_type == AF_INET6) {
1946 cFYI(1, ("looking for ipv6 address"));
1947 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1948 &sin_server6.sin6_addr,
1949 volume_info.username, &srvTcp);
1956 cFYI(1, ("Existing tcp session with server found"));
1957 } else { /* create socket */
1958 if (volume_info.port)
1959 sin_server.sin_port = htons(volume_info.port);
1961 sin_server.sin_port = 0;
1962 if (address_type == AF_INET6) {
1963 cFYI(1, ("attempting ipv6 connect"));
1964 /* BB should we allow ipv6 on port 139? */
1965 /* other OS never observed in Wild doing 139 with v6 */
1966 rc = ipv6_connect(&sin_server6, &csocket);
1968 rc = ipv4_connect(&sin_server, &csocket,
1969 volume_info.source_rfc1001_name,
1970 volume_info.target_rfc1001_name);
1972 cERROR(1, ("Error connecting to IPv4 socket. "
1973 "Aborting operation"));
1974 if (csocket != NULL)
1975 sock_release(csocket);
1979 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1982 sock_release(csocket);
1985 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1986 sizeof(struct sockaddr_in));
1987 atomic_set(&srvTcp->inFlight, 0);
1988 /* BB Add code for ipv6 case too */
1989 srvTcp->ssocket = csocket;
1990 srvTcp->protocolType = IPV4;
1991 srvTcp->hostname = extract_hostname(volume_info.UNC);
1992 if (IS_ERR(srvTcp->hostname)) {
1993 rc = PTR_ERR(srvTcp->hostname);
1994 sock_release(csocket);
1997 init_waitqueue_head(&srvTcp->response_q);
1998 init_waitqueue_head(&srvTcp->request_q);
1999 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
2000 /* at this point we are the only ones with the pointer
2001 to the struct since the kernel thread not created yet
2002 so no need to spinlock this init of tcpStatus */
2003 srvTcp->tcpStatus = CifsNew;
2004 init_MUTEX(&srvTcp->tcpSem);
2005 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
2006 if (IS_ERR(srvTcp->tsk)) {
2007 rc = PTR_ERR(srvTcp->tsk);
2008 cERROR(1, ("error %d create cifsd thread", rc));
2010 sock_release(csocket);
2011 kfree(srvTcp->hostname);
2015 memcpy(srvTcp->workstation_RFC1001_name,
2016 volume_info.source_rfc1001_name, 16);
2017 memcpy(srvTcp->server_RFC1001_name,
2018 volume_info.target_rfc1001_name, 16);
2019 srvTcp->sequence_number = 0;
2023 if (existingCifsSes) {
2024 pSesInfo = existingCifsSes;
2025 cFYI(1, ("Existing smb sess found (status=%d)",
2027 down(&pSesInfo->sesSem);
2028 if (pSesInfo->status == CifsNeedReconnect) {
2029 cFYI(1, ("Session needs reconnect"));
2030 rc = cifs_setup_session(xid, pSesInfo,
2031 cifs_sb->local_nls);
2033 up(&pSesInfo->sesSem);
2035 cFYI(1, ("Existing smb sess not found"));
2036 pSesInfo = sesInfoAlloc();
2037 if (pSesInfo == NULL)
2040 pSesInfo->server = srvTcp;
2041 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
2042 NIPQUAD(sin_server.sin_addr.s_addr));
2046 /* volume_info.password freed at unmount */
2047 if (volume_info.password) {
2048 pSesInfo->password = volume_info.password;
2049 /* set to NULL to prevent freeing on exit */
2050 volume_info.password = NULL;
2052 if (volume_info.username)
2053 strncpy(pSesInfo->userName,
2054 volume_info.username,
2056 if (volume_info.domainname) {
2057 int len = strlen(volume_info.domainname);
2058 pSesInfo->domainName =
2059 kmalloc(len + 1, GFP_KERNEL);
2060 if (pSesInfo->domainName)
2061 strcpy(pSesInfo->domainName,
2062 volume_info.domainname);
2064 pSesInfo->linux_uid = volume_info.linux_uid;
2065 pSesInfo->overrideSecFlg = volume_info.secFlg;
2066 down(&pSesInfo->sesSem);
2067 /* BB FIXME need to pass vol->secFlgs BB */
2068 rc = cifs_setup_session(xid, pSesInfo,
2069 cifs_sb->local_nls);
2070 up(&pSesInfo->sesSem);
2072 atomic_inc(&srvTcp->socketUseCount);
2076 /* search for existing tcon to this server share */
2078 if (volume_info.rsize > CIFSMaxBufSize) {
2079 cERROR(1, ("rsize %d too large, using MaxBufSize",
2080 volume_info.rsize));
2081 cifs_sb->rsize = CIFSMaxBufSize;
2082 } else if ((volume_info.rsize) &&
2083 (volume_info.rsize <= CIFSMaxBufSize))
2084 cifs_sb->rsize = volume_info.rsize;
2086 cifs_sb->rsize = CIFSMaxBufSize;
2088 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2089 cERROR(1, ("wsize %d too large, using 4096 instead",
2090 volume_info.wsize));
2091 cifs_sb->wsize = 4096;
2092 } else if (volume_info.wsize)
2093 cifs_sb->wsize = volume_info.wsize;
2096 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2098 /* old default of CIFSMaxBufSize was too small now
2099 that SMB Write2 can send multiple pages in kvec.
2100 RFC1001 does not describe what happens when frame
2101 bigger than 128K is sent so use that as max in
2102 conjunction with 52K kvec constraint on arch with 4K
2105 if (cifs_sb->rsize < 2048) {
2106 cifs_sb->rsize = 2048;
2107 /* Windows ME may prefer this */
2108 cFYI(1, ("readsize set to minimum: 2048"));
2110 /* calculate prepath */
2111 cifs_sb->prepath = volume_info.prepath;
2112 if (cifs_sb->prepath) {
2113 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2114 /* we can not convert the / to \ in the path
2115 separators in the prefixpath yet because we do not
2116 know (until reset_cifs_unix_caps is called later)
2117 whether POSIX PATH CAP is available. We normalize
2118 the / to \ after reset_cifs_unix_caps is called */
2119 volume_info.prepath = NULL;
2121 cifs_sb->prepathlen = 0;
2122 cifs_sb->mnt_uid = volume_info.linux_uid;
2123 cifs_sb->mnt_gid = volume_info.linux_gid;
2124 cifs_sb->mnt_file_mode = volume_info.file_mode;
2125 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2126 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2127 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2129 if (volume_info.noperm)
2130 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2131 if (volume_info.setuids)
2132 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2133 if (volume_info.server_ino)
2134 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2135 if (volume_info.remap)
2136 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2137 if (volume_info.no_xattr)
2138 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2139 if (volume_info.sfu_emul)
2140 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2141 if (volume_info.nobrl)
2142 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2143 if (volume_info.cifs_acl)
2144 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2145 if (volume_info.override_uid)
2146 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2147 if (volume_info.override_gid)
2148 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2149 if (volume_info.dynperm)
2150 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2151 if (volume_info.direct_io) {
2152 cFYI(1, ("mounting share using direct i/o"));
2153 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2156 if ((volume_info.cifs_acl) && (volume_info.dynperm))
2157 cERROR(1, ("mount option dynperm ignored if cifsacl "
2158 "mount option supported"));
2161 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2162 volume_info.username);
2164 cFYI(1, ("Found match on UNC path"));
2165 /* we can have only one retry value for a connection
2166 to a share so for resources mounted more than once
2167 to the same server share the last value passed in
2168 for the retry flag is used */
2169 tcon->retry = volume_info.retry;
2170 tcon->nocase = volume_info.nocase;
2171 if (tcon->seal != volume_info.seal)
2172 cERROR(1, ("transport encryption setting "
2173 "conflicts with existing tid"));
2175 tcon = tconInfoAlloc();
2179 /* check for null share name ie connecting to
2182 /* BB check if this works for exactly length
2184 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2185 && (strchr(volume_info.UNC + 3, '/') ==
2187 /* rc = connect_to_dfs_path(xid, pSesInfo,
2188 "", cifs_sb->local_nls,
2189 cifs_sb->mnt_cifs_flags &
2190 CIFS_MOUNT_MAP_SPECIAL_CHR);*/
2191 cFYI(1, ("DFS root not supported"));
2195 /* BB Do we need to wrap sesSem around
2196 * this TCon call and Unix SetFS as
2197 * we do on SessSetup and reconnect? */
2198 rc = CIFSTCon(xid, pSesInfo,
2200 tcon, cifs_sb->local_nls);
2201 cFYI(1, ("CIFS Tcon rc = %d", rc));
2204 atomic_inc(&pSesInfo->inUse);
2205 tcon->retry = volume_info.retry;
2206 tcon->nocase = volume_info.nocase;
2207 tcon->seal = volume_info.seal;
2213 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2214 sb->s_maxbytes = (u64) 1 << 63;
2216 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2219 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2220 sb->s_time_gran = 100;
2222 /* on error free sesinfo and tcon struct if needed */
2224 /* if session setup failed, use count is zero but
2225 we still need to free cifsd thread */
2226 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2227 spin_lock(&GlobalMid_Lock);
2228 srvTcp->tcpStatus = CifsExiting;
2229 spin_unlock(&GlobalMid_Lock);
2231 /* If we could verify that kthread_stop would
2232 always wake up processes blocked in
2233 tcp in recv_mesg then we could remove the
2235 force_sig(SIGKILL, srvTcp->tsk);
2236 kthread_stop(srvTcp->tsk);
2239 /* If find_unc succeeded then rc == 0 so we can not end */
2240 if (tcon) /* up accidently freeing someone elses tcon struct */
2242 if (existingCifsSes == NULL) {
2244 if ((pSesInfo->server) &&
2245 (pSesInfo->status == CifsGood)) {
2247 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2248 /* if the socketUseCount is now zero */
2249 if ((temp_rc == -ESHUTDOWN) &&
2250 (pSesInfo->server) &&
2251 (pSesInfo->server->tsk)) {
2253 pSesInfo->server->tsk);
2254 kthread_stop(pSesInfo->server->tsk);
2257 cFYI(1, ("No session or bad tcon"));
2258 if ((pSesInfo->server) &&
2259 (pSesInfo->server->tsk)) {
2261 pSesInfo->server->tsk);
2262 kthread_stop(pSesInfo->server->tsk);
2265 sesInfoFree(pSesInfo);
2266 /* pSesInfo = NULL; */
2270 atomic_inc(&tcon->useCount);
2271 cifs_sb->tcon = tcon;
2272 tcon->ses = pSesInfo;
2274 /* do not care if following two calls succeed - informational */
2276 CIFSSMBQFSDeviceInfo(xid, tcon);
2277 CIFSSMBQFSAttributeInfo(xid, tcon);
2280 /* tell server which Unix caps we support */
2281 if (tcon->ses->capabilities & CAP_UNIX)
2282 /* reset of caps checks mount to see if unix extensions
2283 disabled for just this mount */
2284 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2286 tcon->unix_ext = 0; /* server does not support them */
2288 /* convert forward to back slashes in prepath here if needed */
2289 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2290 convert_delimiter(cifs_sb->prepath,
2291 CIFS_DIR_SEP(cifs_sb));
2293 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2294 cifs_sb->rsize = 1024 * 127;
2296 ("no very large read support, rsize now 127K"));
2298 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2299 cifs_sb->wsize = min(cifs_sb->wsize,
2300 (tcon->ses->server->maxBuf -
2301 MAX_CIFS_HDR_SIZE));
2302 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2303 cifs_sb->rsize = min(cifs_sb->rsize,
2304 (tcon->ses->server->maxBuf -
2305 MAX_CIFS_HDR_SIZE));
2308 /* volume_info.password is freed above when existing session found
2309 (in which case it is not needed anymore) but when new sesion is created
2310 the password ptr is put in the new session structure (in which case the
2311 password will be freed at unmount time) */
2313 /* zero out password before freeing */
2314 if (volume_info.password != NULL) {
2315 memset(volume_info.password, 0, strlen(volume_info.password));
2316 kfree(volume_info.password);
2318 kfree(volume_info.UNC);
2319 kfree(volume_info.prepath);
2325 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2326 char session_key[CIFS_SESS_KEY_SIZE],
2327 const struct nls_table *nls_codepage)
2329 struct smb_hdr *smb_buffer;
2330 struct smb_hdr *smb_buffer_response;
2331 SESSION_SETUP_ANDX *pSMB;
2332 SESSION_SETUP_ANDX *pSMBr;
2337 int remaining_words = 0;
2338 int bytes_returned = 0;
2343 cFYI(1, ("In sesssetup"));
2346 user = ses->userName;
2347 domain = ses->domainName;
2348 smb_buffer = cifs_buf_get();
2350 if (smb_buffer == NULL)
2353 smb_buffer_response = smb_buffer;
2354 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2356 /* send SMBsessionSetup here */
2357 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2358 NULL /* no tCon exists yet */ , 13 /* wct */ );
2360 smb_buffer->Mid = GetNextMid(ses->server);
2361 pSMB->req_no_secext.AndXCommand = 0xFF;
2362 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2363 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2365 if (ses->server->secMode &
2366 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2367 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2369 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2370 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2371 if (ses->capabilities & CAP_UNICODE) {
2372 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2373 capabilities |= CAP_UNICODE;
2375 if (ses->capabilities & CAP_STATUS32) {
2376 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2377 capabilities |= CAP_STATUS32;
2379 if (ses->capabilities & CAP_DFS) {
2380 smb_buffer->Flags2 |= SMBFLG2_DFS;
2381 capabilities |= CAP_DFS;
2383 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2385 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2386 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2388 pSMB->req_no_secext.CaseSensitivePasswordLength =
2389 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2390 bcc_ptr = pByteArea(smb_buffer);
2391 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2392 bcc_ptr += CIFS_SESS_KEY_SIZE;
2393 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2394 bcc_ptr += CIFS_SESS_KEY_SIZE;
2396 if (ses->capabilities & CAP_UNICODE) {
2397 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2402 bytes_returned = 0; /* skip null user */
2405 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2407 /* convert number of 16 bit words to bytes */
2408 bcc_ptr += 2 * bytes_returned;
2409 bcc_ptr += 2; /* trailing null */
2412 cifs_strtoUCS((__le16 *) bcc_ptr,
2413 "CIFS_LINUX_DOM", 32, nls_codepage);
2416 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2418 bcc_ptr += 2 * bytes_returned;
2421 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2423 bcc_ptr += 2 * bytes_returned;
2425 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2427 bcc_ptr += 2 * bytes_returned;
2430 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2432 bcc_ptr += 2 * bytes_returned;
2436 strncpy(bcc_ptr, user, 200);
2437 bcc_ptr += strnlen(user, 200);
2441 if (domain == NULL) {
2442 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2443 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2445 strncpy(bcc_ptr, domain, 64);
2446 bcc_ptr += strnlen(domain, 64);
2450 strcpy(bcc_ptr, "Linux version ");
2451 bcc_ptr += strlen("Linux version ");
2452 strcpy(bcc_ptr, utsname()->release);
2453 bcc_ptr += strlen(utsname()->release) + 1;
2454 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2455 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2457 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2458 smb_buffer->smb_buf_length += count;
2459 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2461 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2462 &bytes_returned, CIFS_LONG_OP);
2464 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2465 } else if ((smb_buffer_response->WordCount == 3)
2466 || (smb_buffer_response->WordCount == 4)) {
2467 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2468 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2469 if (action & GUEST_LOGIN)
2470 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2471 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2473 cFYI(1, ("UID = %d ", ses->Suid));
2474 /* response can have either 3 or 4 word count - Samba sends 3 */
2475 bcc_ptr = pByteArea(smb_buffer_response);
2476 if ((pSMBr->resp.hdr.WordCount == 3)
2477 || ((pSMBr->resp.hdr.WordCount == 4)
2478 && (blob_len < pSMBr->resp.ByteCount))) {
2479 if (pSMBr->resp.hdr.WordCount == 4)
2480 bcc_ptr += blob_len;
2482 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2483 if ((long) (bcc_ptr) % 2) {
2485 (BCC(smb_buffer_response) - 1) / 2;
2486 /* Unicode strings must be word
2491 BCC(smb_buffer_response) / 2;
2494 UniStrnlen((wchar_t *) bcc_ptr,
2495 remaining_words - 1);
2496 /* We look for obvious messed up bcc or strings in response so we do not go off
2497 the end since (at least) WIN2K and Windows XP have a major bug in not null
2498 terminating last Unicode string in response */
2500 kfree(ses->serverOS);
2501 ses->serverOS = kzalloc(2 * (len + 1),
2503 if (ses->serverOS == NULL)
2504 goto sesssetup_nomem;
2505 cifs_strfromUCS_le(ses->serverOS,
2508 bcc_ptr += 2 * (len + 1);
2509 remaining_words -= len + 1;
2510 ses->serverOS[2 * len] = 0;
2511 ses->serverOS[1 + (2 * len)] = 0;
2512 if (remaining_words > 0) {
2513 len = UniStrnlen((wchar_t *)bcc_ptr,
2515 kfree(ses->serverNOS);
2516 ses->serverNOS = kzalloc(2 * (len + 1),
2518 if (ses->serverNOS == NULL)
2519 goto sesssetup_nomem;
2520 cifs_strfromUCS_le(ses->serverNOS,
2523 bcc_ptr += 2 * (len + 1);
2524 ses->serverNOS[2 * len] = 0;
2525 ses->serverNOS[1 + (2 * len)] = 0;
2526 if (strncmp(ses->serverNOS,
2527 "NT LAN Manager 4", 16) == 0) {
2528 cFYI(1, ("NT4 server"));
2529 ses->flags |= CIFS_SES_NT4;
2531 remaining_words -= len + 1;
2532 if (remaining_words > 0) {
2533 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2534 /* last string is not always null terminated
2535 (for e.g. for Windows XP & 2000) */
2536 if (ses->serverDomain)
2537 kfree(ses->serverDomain);
2541 if (ses->serverDomain == NULL)
2542 goto sesssetup_nomem;
2543 cifs_strfromUCS_le(ses->serverDomain,
2546 bcc_ptr += 2 * (len + 1);
2547 ses->serverDomain[2*len] = 0;
2548 ses->serverDomain[1+(2*len)] = 0;
2549 } else { /* else no more room so create
2550 dummy domain string */
2551 if (ses->serverDomain)
2552 kfree(ses->serverDomain);
2554 kzalloc(2, GFP_KERNEL);
2556 } else { /* no room so create dummy domain
2559 /* if these kcallocs fail not much we
2560 can do, but better to not fail the
2562 kfree(ses->serverDomain);
2564 kzalloc(2, GFP_KERNEL);
2565 kfree(ses->serverNOS);
2567 kzalloc(2, GFP_KERNEL);
2569 } else { /* ASCII */
2570 len = strnlen(bcc_ptr, 1024);
2571 if (((long) bcc_ptr + len) - (long)
2572 pByteArea(smb_buffer_response)
2573 <= BCC(smb_buffer_response)) {
2574 kfree(ses->serverOS);
2575 ses->serverOS = kzalloc(len + 1,
2577 if (ses->serverOS == NULL)
2578 goto sesssetup_nomem;
2579 strncpy(ses->serverOS, bcc_ptr, len);
2582 /* null terminate the string */
2586 len = strnlen(bcc_ptr, 1024);
2587 kfree(ses->serverNOS);
2588 ses->serverNOS = kzalloc(len + 1,
2590 if (ses->serverNOS == NULL)
2591 goto sesssetup_nomem;
2592 strncpy(ses->serverNOS, bcc_ptr, len);
2597 len = strnlen(bcc_ptr, 1024);
2598 if (ses->serverDomain)
2599 kfree(ses->serverDomain);
2600 ses->serverDomain = kzalloc(len + 1,
2602 if (ses->serverDomain == NULL)
2603 goto sesssetup_nomem;
2604 strncpy(ses->serverDomain, bcc_ptr,
2611 ("Variable field of length %d "
2612 "extends beyond end of smb ",
2617 (" Security Blob Length extends beyond "
2622 (" Invalid Word count %d: ",
2623 smb_buffer_response->WordCount));
2626 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2627 since that could make reconnection harder, and
2628 reconnection might be needed to free memory */
2629 cifs_buf_release(smb_buffer);
2635 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2636 struct cifsSesInfo *ses, bool *pNTLMv2_flag,
2637 const struct nls_table *nls_codepage)
2639 struct smb_hdr *smb_buffer;
2640 struct smb_hdr *smb_buffer_response;
2641 SESSION_SETUP_ANDX *pSMB;
2642 SESSION_SETUP_ANDX *pSMBr;
2646 int remaining_words = 0;
2647 int bytes_returned = 0;
2649 int SecurityBlobLength = sizeof(NEGOTIATE_MESSAGE);
2650 PNEGOTIATE_MESSAGE SecurityBlob;
2651 PCHALLENGE_MESSAGE SecurityBlob2;
2652 __u32 negotiate_flags, capabilities;
2655 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2658 domain = ses->domainName;
2659 *pNTLMv2_flag = false;
2660 smb_buffer = cifs_buf_get();
2661 if (smb_buffer == NULL) {
2664 smb_buffer_response = smb_buffer;
2665 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2666 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2668 /* send SMBsessionSetup here */
2669 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2670 NULL /* no tCon exists yet */ , 12 /* wct */ );
2672 smb_buffer->Mid = GetNextMid(ses->server);
2673 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2674 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2676 pSMB->req.AndXCommand = 0xFF;
2677 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2678 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2680 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2681 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2683 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2684 CAP_EXTENDED_SECURITY;
2685 if (ses->capabilities & CAP_UNICODE) {
2686 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2687 capabilities |= CAP_UNICODE;
2689 if (ses->capabilities & CAP_STATUS32) {
2690 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2691 capabilities |= CAP_STATUS32;
2693 if (ses->capabilities & CAP_DFS) {
2694 smb_buffer->Flags2 |= SMBFLG2_DFS;
2695 capabilities |= CAP_DFS;
2697 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2699 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2700 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2701 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2702 SecurityBlob->MessageType = NtLmNegotiate;
2704 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2705 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2706 NTLMSSP_NEGOTIATE_56 |
2707 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2709 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2710 /* if (ntlmv2_support)
2711 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2712 /* setup pointers to domain name and workstation name */
2713 bcc_ptr += SecurityBlobLength;
2715 SecurityBlob->WorkstationName.Buffer = 0;
2716 SecurityBlob->WorkstationName.Length = 0;
2717 SecurityBlob->WorkstationName.MaximumLength = 0;
2719 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2720 along with username on auth request (ie the response to challenge) */
2721 SecurityBlob->DomainName.Buffer = 0;
2722 SecurityBlob->DomainName.Length = 0;
2723 SecurityBlob->DomainName.MaximumLength = 0;
2724 if (ses->capabilities & CAP_UNICODE) {
2725 if ((long) bcc_ptr % 2) {
2731 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2733 bcc_ptr += 2 * bytes_returned;
2735 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2737 bcc_ptr += 2 * bytes_returned;
2738 bcc_ptr += 2; /* null terminate Linux version */
2740 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2742 bcc_ptr += 2 * bytes_returned;
2745 bcc_ptr += 2; /* null terminate network opsys string */
2748 bcc_ptr += 2; /* null domain */
2749 } else { /* ASCII */
2750 strcpy(bcc_ptr, "Linux version ");
2751 bcc_ptr += strlen("Linux version ");
2752 strcpy(bcc_ptr, utsname()->release);
2753 bcc_ptr += strlen(utsname()->release) + 1;
2754 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2755 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2756 bcc_ptr++; /* empty domain field */
2759 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2760 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2761 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2762 smb_buffer->smb_buf_length += count;
2763 pSMB->req.ByteCount = cpu_to_le16(count);
2765 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2766 &bytes_returned, CIFS_LONG_OP);
2768 if (smb_buffer_response->Status.CifsError ==
2769 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2773 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2774 } else if ((smb_buffer_response->WordCount == 3)
2775 || (smb_buffer_response->WordCount == 4)) {
2776 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2777 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2779 if (action & GUEST_LOGIN)
2780 cFYI(1, (" Guest login"));
2781 /* Do we want to set anything in SesInfo struct when guest login? */
2783 bcc_ptr = pByteArea(smb_buffer_response);
2784 /* response can have either 3 or 4 word count - Samba sends 3 */
2786 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2787 if (SecurityBlob2->MessageType != NtLmChallenge) {
2789 ("Unexpected NTLMSSP message type received %d",
2790 SecurityBlob2->MessageType));
2792 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2793 cFYI(1, ("UID = %d", ses->Suid));
2794 if ((pSMBr->resp.hdr.WordCount == 3)
2795 || ((pSMBr->resp.hdr.WordCount == 4)
2797 pSMBr->resp.ByteCount))) {
2799 if (pSMBr->resp.hdr.WordCount == 4) {
2800 bcc_ptr += blob_len;
2801 cFYI(1, ("Security Blob Length %d",
2805 cFYI(1, ("NTLMSSP Challenge rcvd"));
2807 memcpy(ses->server->cryptKey,
2808 SecurityBlob2->Challenge,
2809 CIFS_CRYPTO_KEY_SIZE);
2810 if (SecurityBlob2->NegotiateFlags &
2811 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2812 *pNTLMv2_flag = true;
2814 if ((SecurityBlob2->NegotiateFlags &
2815 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2816 || (sign_CIFS_PDUs > 1))
2817 ses->server->secMode |=
2818 SECMODE_SIGN_REQUIRED;
2819 if ((SecurityBlob2->NegotiateFlags &
2820 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2821 ses->server->secMode |=
2822 SECMODE_SIGN_ENABLED;
2824 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2825 if ((long) (bcc_ptr) % 2) {
2827 (BCC(smb_buffer_response)
2829 /* Must word align unicode strings */
2834 (smb_buffer_response) / 2;
2837 UniStrnlen((wchar_t *) bcc_ptr,
2838 remaining_words - 1);
2839 /* We look for obvious messed up bcc or strings in response so we do not go off
2840 the end since (at least) WIN2K and Windows XP have a major bug in not null
2841 terminating last Unicode string in response */
2843 kfree(ses->serverOS);
2845 kzalloc(2 * (len + 1), GFP_KERNEL);
2846 cifs_strfromUCS_le(ses->serverOS,
2850 bcc_ptr += 2 * (len + 1);
2851 remaining_words -= len + 1;
2852 ses->serverOS[2 * len] = 0;
2853 ses->serverOS[1 + (2 * len)] = 0;
2854 if (remaining_words > 0) {
2855 len = UniStrnlen((wchar_t *)
2859 kfree(ses->serverNOS);
2861 kzalloc(2 * (len + 1),
2863 cifs_strfromUCS_le(ses->
2869 bcc_ptr += 2 * (len + 1);
2870 ses->serverNOS[2 * len] = 0;
2873 remaining_words -= len + 1;
2874 if (remaining_words > 0) {
2875 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2876 /* last string not always null terminated
2877 (for e.g. for Windows XP & 2000) */
2878 kfree(ses->serverDomain);
2890 ses->serverDomain[2*len]
2895 } /* else no more room so create dummy domain string */
2897 kfree(ses->serverDomain);
2902 } else { /* no room so create dummy domain and NOS string */
2903 kfree(ses->serverDomain);
2905 kzalloc(2, GFP_KERNEL);
2906 kfree(ses->serverNOS);
2908 kzalloc(2, GFP_KERNEL);
2910 } else { /* ASCII */
2911 len = strnlen(bcc_ptr, 1024);
2912 if (((long) bcc_ptr + len) - (long)
2913 pByteArea(smb_buffer_response)
2914 <= BCC(smb_buffer_response)) {
2916 kfree(ses->serverOS);
2920 strncpy(ses->serverOS,
2924 bcc_ptr[0] = 0; /* null terminate string */
2927 len = strnlen(bcc_ptr, 1024);
2928 kfree(ses->serverNOS);
2932 strncpy(ses->serverNOS, bcc_ptr, len);
2937 len = strnlen(bcc_ptr, 1024);
2938 kfree(ses->serverDomain);
2942 strncpy(ses->serverDomain,
2949 ("field of length %d "
2950 "extends beyond end of smb",
2954 cERROR(1, ("Security Blob Length extends beyond"
2958 cERROR(1, ("No session structure passed in."));
2962 (" Invalid Word count %d:",
2963 smb_buffer_response->WordCount));
2967 cifs_buf_release(smb_buffer);
2972 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2973 char *ntlm_session_key, bool ntlmv2_flag,
2974 const struct nls_table *nls_codepage)
2976 struct smb_hdr *smb_buffer;
2977 struct smb_hdr *smb_buffer_response;
2978 SESSION_SETUP_ANDX *pSMB;
2979 SESSION_SETUP_ANDX *pSMBr;
2984 int remaining_words = 0;
2985 int bytes_returned = 0;
2987 int SecurityBlobLength = sizeof(AUTHENTICATE_MESSAGE);
2988 PAUTHENTICATE_MESSAGE SecurityBlob;
2989 __u32 negotiate_flags, capabilities;
2992 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2995 user = ses->userName;
2996 domain = ses->domainName;
2997 smb_buffer = cifs_buf_get();
2998 if (smb_buffer == NULL) {
3001 smb_buffer_response = smb_buffer;
3002 pSMB = (SESSION_SETUP_ANDX *)smb_buffer;
3003 pSMBr = (SESSION_SETUP_ANDX *)smb_buffer_response;
3005 /* send SMBsessionSetup here */
3006 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
3007 NULL /* no tCon exists yet */ , 12 /* wct */ );
3009 smb_buffer->Mid = GetNextMid(ses->server);
3010 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
3011 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
3012 pSMB->req.AndXCommand = 0xFF;
3013 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
3014 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
3016 pSMB->req.hdr.Uid = ses->Suid;
3018 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3019 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3021 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
3022 CAP_EXTENDED_SECURITY;
3023 if (ses->capabilities & CAP_UNICODE) {
3024 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3025 capabilities |= CAP_UNICODE;
3027 if (ses->capabilities & CAP_STATUS32) {
3028 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3029 capabilities |= CAP_STATUS32;
3031 if (ses->capabilities & CAP_DFS) {
3032 smb_buffer->Flags2 |= SMBFLG2_DFS;
3033 capabilities |= CAP_DFS;
3035 pSMB->req.Capabilities = cpu_to_le32(capabilities);
3037 bcc_ptr = (char *)&pSMB->req.SecurityBlob;
3038 SecurityBlob = (PAUTHENTICATE_MESSAGE)bcc_ptr;
3039 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
3040 SecurityBlob->MessageType = NtLmAuthenticate;
3041 bcc_ptr += SecurityBlobLength;
3042 negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
3043 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
3044 0x80000000 | NTLMSSP_NEGOTIATE_128;
3046 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
3048 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
3050 /* setup pointers to domain name and workstation name */
3052 SecurityBlob->WorkstationName.Buffer = 0;
3053 SecurityBlob->WorkstationName.Length = 0;
3054 SecurityBlob->WorkstationName.MaximumLength = 0;
3055 SecurityBlob->SessionKey.Length = 0;
3056 SecurityBlob->SessionKey.MaximumLength = 0;
3057 SecurityBlob->SessionKey.Buffer = 0;
3059 SecurityBlob->LmChallengeResponse.Length = 0;
3060 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
3061 SecurityBlob->LmChallengeResponse.Buffer = 0;
3063 SecurityBlob->NtChallengeResponse.Length =
3064 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3065 SecurityBlob->NtChallengeResponse.MaximumLength =
3066 cpu_to_le16(CIFS_SESS_KEY_SIZE);
3067 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
3068 SecurityBlob->NtChallengeResponse.Buffer =
3069 cpu_to_le32(SecurityBlobLength);
3070 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
3071 bcc_ptr += CIFS_SESS_KEY_SIZE;
3073 if (ses->capabilities & CAP_UNICODE) {
3074 if (domain == NULL) {
3075 SecurityBlob->DomainName.Buffer = 0;
3076 SecurityBlob->DomainName.Length = 0;
3077 SecurityBlob->DomainName.MaximumLength = 0;
3079 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
3082 SecurityBlob->DomainName.MaximumLength =
3084 SecurityBlob->DomainName.Buffer =
3085 cpu_to_le32(SecurityBlobLength);
3087 SecurityBlobLength += ln;
3088 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3091 SecurityBlob->UserName.Buffer = 0;
3092 SecurityBlob->UserName.Length = 0;
3093 SecurityBlob->UserName.MaximumLength = 0;
3095 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3098 SecurityBlob->UserName.MaximumLength =
3100 SecurityBlob->UserName.Buffer =
3101 cpu_to_le32(SecurityBlobLength);
3103 SecurityBlobLength += ln;
3104 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3107 /* SecurityBlob->WorkstationName.Length =
3108 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3109 SecurityBlob->WorkstationName.Length *= 2;
3110 SecurityBlob->WorkstationName.MaximumLength =
3111 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3112 SecurityBlob->WorkstationName.Buffer =
3113 cpu_to_le32(SecurityBlobLength);
3114 bcc_ptr += SecurityBlob->WorkstationName.Length;
3115 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3116 SecurityBlob->WorkstationName.Length =
3117 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3119 if ((long) bcc_ptr % 2) {
3124 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3126 bcc_ptr += 2 * bytes_returned;
3128 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3130 bcc_ptr += 2 * bytes_returned;
3131 bcc_ptr += 2; /* null term version string */
3133 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3135 bcc_ptr += 2 * bytes_returned;
3138 bcc_ptr += 2; /* null terminate network opsys string */
3141 bcc_ptr += 2; /* null domain */
3142 } else { /* ASCII */
3143 if (domain == NULL) {
3144 SecurityBlob->DomainName.Buffer = 0;
3145 SecurityBlob->DomainName.Length = 0;
3146 SecurityBlob->DomainName.MaximumLength = 0;
3149 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3150 strncpy(bcc_ptr, domain, 63);
3151 ln = strnlen(domain, 64);
3152 SecurityBlob->DomainName.MaximumLength =
3154 SecurityBlob->DomainName.Buffer =
3155 cpu_to_le32(SecurityBlobLength);
3157 SecurityBlobLength += ln;
3158 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3161 SecurityBlob->UserName.Buffer = 0;
3162 SecurityBlob->UserName.Length = 0;
3163 SecurityBlob->UserName.MaximumLength = 0;
3166 strncpy(bcc_ptr, user, 63);
3167 ln = strnlen(user, 64);
3168 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3169 SecurityBlob->UserName.Buffer =
3170 cpu_to_le32(SecurityBlobLength);
3172 SecurityBlobLength += ln;
3173 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3175 /* BB fill in our workstation name if known BB */
3177 strcpy(bcc_ptr, "Linux version ");
3178 bcc_ptr += strlen("Linux version ");
3179 strcpy(bcc_ptr, utsname()->release);
3180 bcc_ptr += strlen(utsname()->release) + 1;
3181 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3182 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3183 bcc_ptr++; /* null domain */
3186 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3187 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3188 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3189 smb_buffer->smb_buf_length += count;
3190 pSMB->req.ByteCount = cpu_to_le16(count);
3192 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3193 &bytes_returned, CIFS_LONG_OP);
3195 /* rc = map_smb_to_linux_error(smb_buffer_response) done in SendReceive now */
3196 } else if ((smb_buffer_response->WordCount == 3) ||
3197 (smb_buffer_response->WordCount == 4)) {
3198 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3199 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3200 if (action & GUEST_LOGIN)
3201 cFYI(1, (" Guest login")); /* BB Should we set anything
3202 in SesInfo struct ? */
3203 /* if (SecurityBlob2->MessageType != NtLm??) {
3204 cFYI("Unexpected message type on auth response is %d"));
3209 ("Check challenge UID %d vs auth response UID %d",
3210 ses->Suid, smb_buffer_response->Uid));
3211 /* UID left in wire format */
3212 ses->Suid = smb_buffer_response->Uid;
3213 bcc_ptr = pByteArea(smb_buffer_response);
3214 /* response can have either 3 or 4 word count - Samba sends 3 */
3215 if ((pSMBr->resp.hdr.WordCount == 3)
3216 || ((pSMBr->resp.hdr.WordCount == 4)
3218 pSMBr->resp.ByteCount))) {
3219 if (pSMBr->resp.hdr.WordCount == 4) {
3223 ("Security Blob Length %d ",
3228 ("NTLMSSP response to Authenticate "));
3230 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3231 if ((long) (bcc_ptr) % 2) {
3233 (BCC(smb_buffer_response)
3235 bcc_ptr++; /* Unicode strings must be word aligned */
3237 remaining_words = BCC(smb_buffer_response) / 2;
3239 len = UniStrnlen((wchar_t *) bcc_ptr,
3240 remaining_words - 1);
3241 /* We look for obvious messed up bcc or strings in response so we do not go off
3242 the end since (at least) WIN2K and Windows XP have a major bug in not null
3243 terminating last Unicode string in response */
3245 kfree(ses->serverOS);
3247 kzalloc(2 * (len + 1), GFP_KERNEL);
3248 cifs_strfromUCS_le(ses->serverOS,
3252 bcc_ptr += 2 * (len + 1);
3253 remaining_words -= len + 1;
3254 ses->serverOS[2 * len] = 0;
3255 ses->serverOS[1 + (2 * len)] = 0;
3256 if (remaining_words > 0) {
3257 len = UniStrnlen((wchar_t *)
3261 kfree(ses->serverNOS);
3263 kzalloc(2 * (len + 1),
3265 cifs_strfromUCS_le(ses->
3271 bcc_ptr += 2 * (len + 1);
3272 ses->serverNOS[2 * len] = 0;
3273 ses->serverNOS[1+(2*len)] = 0;
3274 remaining_words -= len + 1;
3275 if (remaining_words > 0) {
3276 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3277 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3278 if (ses->serverDomain)
3279 kfree(ses->serverDomain);
3304 } /* else no more room so create dummy domain string */
3306 if (ses->serverDomain)
3307 kfree(ses->serverDomain);
3308 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3310 } else { /* no room so create dummy domain and NOS string */
3311 if (ses->serverDomain)
3312 kfree(ses->serverDomain);
3313 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3314 kfree(ses->serverNOS);
3315 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3317 } else { /* ASCII */
3318 len = strnlen(bcc_ptr, 1024);
3319 if (((long) bcc_ptr + len) -
3320 (long) pByteArea(smb_buffer_response)
3321 <= BCC(smb_buffer_response)) {
3323 kfree(ses->serverOS);
3324 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3325 strncpy(ses->serverOS,bcc_ptr, len);
3328 bcc_ptr[0] = 0; /* null terminate the string */
3331 len = strnlen(bcc_ptr, 1024);
3332 kfree(ses->serverNOS);
3333 ses->serverNOS = kzalloc(len+1,
3335 strncpy(ses->serverNOS,
3341 len = strnlen(bcc_ptr, 1024);
3342 if (ses->serverDomain)
3343 kfree(ses->serverDomain);
3347 strncpy(ses->serverDomain,
3353 cFYI(1, ("field of length %d "
3354 "extends beyond end of smb ",
3358 cERROR(1, ("Security Blob extends beyond end "
3362 cERROR(1, ("No session structure passed in."));
3365 cERROR(1, ("Invalid Word count %d: ",
3366 smb_buffer_response->WordCount));
3370 cifs_buf_release(smb_buffer);
3376 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3377 const char *tree, struct cifsTconInfo *tcon,
3378 const struct nls_table *nls_codepage)
3380 struct smb_hdr *smb_buffer;
3381 struct smb_hdr *smb_buffer_response;
3384 unsigned char *bcc_ptr;
3392 smb_buffer = cifs_buf_get();
3393 if (smb_buffer == NULL) {
3396 smb_buffer_response = smb_buffer;
3398 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3399 NULL /*no tid */ , 4 /*wct */ );
3401 smb_buffer->Mid = GetNextMid(ses->server);
3402 smb_buffer->Uid = ses->Suid;
3403 pSMB = (TCONX_REQ *) smb_buffer;
3404 pSMBr = (TCONX_RSP *) smb_buffer_response;
3406 pSMB->AndXCommand = 0xFF;
3407 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3408 bcc_ptr = &pSMB->Password[0];
3409 if ((ses->server->secMode) & SECMODE_USER) {
3410 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3411 *bcc_ptr = 0; /* password is null byte */
3412 bcc_ptr++; /* skip password */
3413 /* already aligned so no need to do it below */
3415 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3416 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3417 specified as required (when that support is added to
3418 the vfs in the future) as only NTLM or the much
3419 weaker LANMAN (which we do not send by default) is accepted
3420 by Samba (not sure whether other servers allow
3421 NTLMv2 password here) */
3422 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3423 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3424 (ses->server->secType == LANMAN))
3425 calc_lanman_hash(ses, bcc_ptr);
3427 #endif /* CIFS_WEAK_PW_HASH */
3428 SMBNTencrypt(ses->password,
3429 ses->server->cryptKey,
3432 bcc_ptr += CIFS_SESS_KEY_SIZE;
3433 if (ses->capabilities & CAP_UNICODE) {
3434 /* must align unicode strings */
3435 *bcc_ptr = 0; /* null byte password */
3440 if (ses->server->secMode &
3441 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3442 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3444 if (ses->capabilities & CAP_STATUS32) {
3445 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3447 if (ses->capabilities & CAP_DFS) {
3448 smb_buffer->Flags2 |= SMBFLG2_DFS;
3450 if (ses->capabilities & CAP_UNICODE) {
3451 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3453 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3454 6 /* max utf8 char length in bytes */ *
3455 (/* server len*/ + 256 /* share len */), nls_codepage);
3456 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3457 bcc_ptr += 2; /* skip trailing null */
3458 } else { /* ASCII */
3459 strcpy(bcc_ptr, tree);
3460 bcc_ptr += strlen(tree) + 1;
3462 strcpy(bcc_ptr, "?????");
3463 bcc_ptr += strlen("?????");
3465 count = bcc_ptr - &pSMB->Password[0];
3466 pSMB->hdr.smb_buf_length += count;
3467 pSMB->ByteCount = cpu_to_le16(count);
3469 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3472 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3473 /* above now done in SendReceive */
3474 if ((rc == 0) && (tcon != NULL)) {
3475 tcon->tidStatus = CifsGood;
3476 tcon->tid = smb_buffer_response->Tid;
3477 bcc_ptr = pByteArea(smb_buffer_response);
3478 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3479 /* skip service field (NB: this field is always ASCII) */
3481 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3482 (bcc_ptr[2] == 'C')) {
3483 cFYI(1, ("IPC connection"));
3486 } else if (length == 2) {
3487 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3488 /* the most common case */
3489 cFYI(1, ("disk share connection"));
3492 bcc_ptr += length + 1;
3493 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3494 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3495 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3496 if ((bcc_ptr + (2 * length)) -
3497 pByteArea(smb_buffer_response) <=
3498 BCC(smb_buffer_response)) {
3499 kfree(tcon->nativeFileSystem);
3500 tcon->nativeFileSystem =
3501 kzalloc(length + 2, GFP_KERNEL);
3502 if (tcon->nativeFileSystem)
3504 tcon->nativeFileSystem,
3506 length, nls_codepage);
3507 bcc_ptr += 2 * length;
3508 bcc_ptr[0] = 0; /* null terminate the string */
3512 /* else do not bother copying these information fields*/
3514 length = strnlen(bcc_ptr, 1024);
3515 if ((bcc_ptr + length) -
3516 pByteArea(smb_buffer_response) <=
3517 BCC(smb_buffer_response)) {
3518 kfree(tcon->nativeFileSystem);
3519 tcon->nativeFileSystem =
3520 kzalloc(length + 1, GFP_KERNEL);
3521 if (tcon->nativeFileSystem)
3522 strncpy(tcon->nativeFileSystem, bcc_ptr,
3525 /* else do not bother copying these information fields*/
3527 if ((smb_buffer_response->WordCount == 3) ||
3528 (smb_buffer_response->WordCount == 7))
3529 /* field is in same location */
3530 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3533 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3534 } else if ((rc == 0) && tcon == NULL) {
3535 /* all we need to save for IPC$ connection */
3536 ses->ipc_tid = smb_buffer_response->Tid;
3539 cifs_buf_release(smb_buffer);
3544 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3548 struct cifsSesInfo *ses = NULL;
3549 struct task_struct *cifsd_task;
3554 if (cifs_sb->tcon) {
3555 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3556 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3561 DeleteTconOplockQEntries(cifs_sb->tcon);
3562 tconInfoFree(cifs_sb->tcon);
3563 if ((ses) && (ses->server)) {
3564 /* save off task so we do not refer to ses later */
3565 cifsd_task = ses->server->tsk;
3566 cFYI(1, ("About to do SMBLogoff "));
3567 rc = CIFSSMBLogoff(xid, ses);
3571 } else if (rc == -ESHUTDOWN) {
3572 cFYI(1, ("Waking up socket by sending signal"));
3574 force_sig(SIGKILL, cifsd_task);
3575 kthread_stop(cifsd_task);
3578 } /* else - we have an smb session
3579 left on this socket do not kill cifsd */
3581 cFYI(1, ("No session or bad tcon"));
3584 cifs_sb->tcon = NULL;
3585 tmp = cifs_sb->prepath;
3586 cifs_sb->prepathlen = 0;
3587 cifs_sb->prepath = NULL;
3596 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3597 struct nls_table *nls_info)
3600 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3601 bool ntlmv2_flag = false;
3604 /* what if server changes its buffer size after dropping the session? */
3605 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3606 rc = CIFSSMBNegotiate(xid, pSesInfo);
3607 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3608 rc = CIFSSMBNegotiate(xid, pSesInfo);
3613 spin_lock(&GlobalMid_Lock);
3614 if (pSesInfo->server->tcpStatus != CifsExiting)
3615 pSesInfo->server->tcpStatus = CifsGood;
3618 spin_unlock(&GlobalMid_Lock);
3627 pSesInfo->flags = 0;
3628 pSesInfo->capabilities = pSesInfo->server->capabilities;
3629 if (linuxExtEnabled == 0)
3630 pSesInfo->capabilities &= (~CAP_UNIX);
3631 /* pSesInfo->sequence_number = 0;*/
3632 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3633 pSesInfo->server->secMode,
3634 pSesInfo->server->capabilities,
3635 pSesInfo->server->timeAdj));
3636 if (experimEnabled < 2)
3637 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
3638 else if (extended_security
3639 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3640 && (pSesInfo->server->secType == NTLMSSP)) {
3642 } else if (extended_security
3643 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3644 && (pSesInfo->server->secType == RawNTLMSSP)) {
3645 cFYI(1, ("NTLMSSP sesssetup"));
3646 rc = CIFSNTLMSSPNegotiateSessSetup(xid, pSesInfo, &ntlmv2_flag,
3651 cFYI(1, ("more secure NTLM ver2 hash"));
3652 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3657 v2_response = kmalloc(16 + 64 /* blob*/,
3660 CalcNTLMv2_response(pSesInfo,
3663 cifs_calculate_ntlmv2_mac_key */
3665 /* BB Put dummy sig in SessSetup PDU? */
3672 SMBNTencrypt(pSesInfo->password,
3673 pSesInfo->server->cryptKey,
3677 cifs_calculate_mac_key(
3678 &pSesInfo->server->mac_signing_key,
3680 pSesInfo->password);
3682 /* for better security the weaker lanman hash not sent
3683 in AuthSessSetup so we no longer calculate it */
3685 rc = CIFSNTLMSSPAuthSessSetup(xid, pSesInfo,
3690 } else { /* old style NTLM 0.12 session setup */
3691 SMBNTencrypt(pSesInfo->password, pSesInfo->server->cryptKey,
3695 cifs_calculate_mac_key(
3696 &pSesInfo->server->mac_signing_key,
3697 ntlm_session_key, pSesInfo->password);
3699 rc = CIFSSessSetup(xid, pSesInfo, ntlm_session_key, nls_info);
3702 cERROR(1, ("Send error in SessSetup = %d", rc));
3704 cFYI(1, ("CIFS Session Established successfully"));
3705 pSesInfo->status = CifsGood;