4 * Copyright (C) International Business Machines Corp., 2002,2007
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/ipv6.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 #include "rfc1002pdu.h"
50 #define RFC1001_PORT 139
52 static DECLARE_COMPLETION(cifsd_complete);
54 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
57 extern mempool_t *cifs_req_poolp;
65 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[16]; /* netbios name of client */
68 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
78 unsigned override_uid:1;
79 unsigned override_gid:1;
81 unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
83 unsigned no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 unsigned server_ino:1; /* use inode numbers from server ie UniqueId */
86 unsigned remap:1; /* set to remap seven reserved chars in filenames */
87 unsigned posix_paths:1; /* unset to not ask for posix pathnames. */
88 unsigned no_linux_ext:1;
90 unsigned nullauth:1; /* attempt to authenticate with null user */
91 unsigned nocase; /* request case insensitive filenames */
92 unsigned nobrl; /* disable sending byte range locks to srv */
96 unsigned short int port;
100 static int ipv4_connect(struct sockaddr_in *psin_server,
101 struct socket **csocket,
103 char *server_netb_name);
104 static int ipv6_connect(struct sockaddr_in6 *psin_server,
105 struct socket **csocket);
109 * cifs tcp session reconnection
111 * mark tcp session as reconnecting so temporarily locked
112 * mark all smb sessions as reconnecting for tcp session
113 * reconnect tcp session
114 * wake up waiters on reconnection? - (not needed currently)
118 cifs_reconnect(struct TCP_Server_Info *server)
121 struct list_head *tmp;
122 struct cifsSesInfo *ses;
123 struct cifsTconInfo *tcon;
124 struct mid_q_entry *mid_entry;
126 spin_lock(&GlobalMid_Lock);
127 if (kthread_should_stop()) {
128 /* the demux thread will exit normally
129 next time through the loop */
130 spin_unlock(&GlobalMid_Lock);
133 server->tcpStatus = CifsNeedReconnect;
134 spin_unlock(&GlobalMid_Lock);
137 cFYI(1, ("Reconnecting tcp session"));
139 /* before reconnecting the tcp session, mark the smb session (uid)
140 and the tid bad so they are not used until reconnected */
141 read_lock(&GlobalSMBSeslock);
142 list_for_each(tmp, &GlobalSMBSessionList) {
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
145 if (ses->server == server) {
146 ses->status = CifsNeedReconnect;
150 /* else tcp and smb sessions need reconnection */
152 list_for_each(tmp, &GlobalTreeConnectionList) {
153 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
154 if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
155 tcon->tidStatus = CifsNeedReconnect;
157 read_unlock(&GlobalSMBSeslock);
158 /* do not want to be sending data on a socket we are freeing */
159 down(&server->tcpSem);
160 if (server->ssocket) {
161 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
162 server->ssocket->flags));
163 server->ssocket->ops->shutdown(server->ssocket, SEND_SHUTDOWN);
164 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
165 server->ssocket->state,
166 server->ssocket->flags));
167 sock_release(server->ssocket);
168 server->ssocket = NULL;
171 spin_lock(&GlobalMid_Lock);
172 list_for_each(tmp, &server->pending_mid_q) {
173 mid_entry = list_entry(tmp, struct
177 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
178 /* Mark other intransit requests as needing
179 retry so we do not immediately mark the
180 session bad again (ie after we reconnect
181 below) as they timeout too */
182 mid_entry->midState = MID_RETRY_NEEDED;
186 spin_unlock(&GlobalMid_Lock);
189 while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
191 if (server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,
195 rc = ipv4_connect(&server->addr.sockAddr,
197 server->workstation_RFC1001_name,
198 server->server_RFC1001_name);
201 cFYI(1, ("reconnect error %d", rc));
204 atomic_inc(&tcpSesReconnectCount);
205 spin_lock(&GlobalMid_Lock);
206 if (!kthread_should_stop())
207 server->tcpStatus = CifsGood;
208 server->sequence_number = 0;
209 spin_unlock(&GlobalMid_Lock);
210 /* atomic_set(&server->inFlight,0);*/
211 wake_up(&server->response_q);
219 0 not a transact2, or all data present
220 >0 transact2 with that much data missing
221 -EINVAL = invalid transact2
224 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
226 struct smb_t2_rsp *pSMBt;
228 int data_in_this_rsp;
231 if (pSMB->Command != SMB_COM_TRANSACTION2)
234 /* check for plausible wct, bcc and t2 data and parm sizes */
235 /* check for parm and data offset going beyond end of smb */
236 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
237 cFYI(1, ("invalid transact2 word count"));
241 pSMBt = (struct smb_t2_rsp *)pSMB;
243 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
244 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
246 remaining = total_data_size - data_in_this_rsp;
250 else if (remaining < 0) {
251 cFYI(1, ("total data %d smaller than data in frame %d",
252 total_data_size, data_in_this_rsp));
255 cFYI(1, ("missing %d bytes from transact2, check next response",
257 if (total_data_size > maxBufSize) {
258 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
259 total_data_size, maxBufSize));
266 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
268 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
269 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
274 char *data_area_of_target;
275 char *data_area_of_buf2;
278 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
280 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
281 cFYI(1, ("total data size of primary and secondary t2 differ"));
284 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
286 remaining = total_data_size - total_in_buf;
291 if (remaining == 0) /* nothing to do, ignore */
294 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
295 if (remaining < total_in_buf2) {
296 cFYI(1, ("transact2 2nd response contains too much data"));
299 /* find end of first SMB data area */
300 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
301 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
302 /* validate target area */
304 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
305 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
307 data_area_of_target += total_in_buf;
309 /* copy second buffer into end of first buffer */
310 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
311 total_in_buf += total_in_buf2;
312 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
313 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
314 byte_count += total_in_buf2;
315 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
317 byte_count = pTargetSMB->smb_buf_length;
318 byte_count += total_in_buf2;
320 /* BB also add check that we are not beyond maximum buffer size */
322 pTargetSMB->smb_buf_length = byte_count;
324 if (remaining == total_in_buf2) {
325 cFYI(1, ("found the last secondary response"));
326 return 0; /* we are done */
327 } else /* more responses to go */
333 cifs_demultiplex_thread(struct TCP_Server_Info *server)
336 unsigned int pdu_length, total_read;
337 struct smb_hdr *smb_buffer = NULL;
338 struct smb_hdr *bigbuf = NULL;
339 struct smb_hdr *smallbuf = NULL;
340 struct msghdr smb_msg;
342 struct socket *csocket = server->ssocket;
343 struct list_head *tmp;
344 struct cifsSesInfo *ses;
345 struct task_struct *task_to_wake = NULL;
346 struct mid_q_entry *mid_entry;
348 int isLargeBuf = FALSE;
352 current->flags |= PF_MEMALLOC;
353 server->tsk = current; /* save process info to wake at shutdown */
354 cFYI(1, ("Demultiplex PID: %d", current->pid));
355 write_lock(&GlobalSMBSeslock);
356 atomic_inc(&tcpSesAllocCount);
357 length = tcpSesAllocCount.counter;
358 write_unlock(&GlobalSMBSeslock);
359 complete(&cifsd_complete);
361 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
365 while (!kthread_should_stop()) {
368 if (bigbuf == NULL) {
369 bigbuf = cifs_buf_get();
371 cERROR(1, ("No memory for large SMB response"));
373 /* retry will check if exiting */
376 } else if (isLargeBuf) {
377 /* we are reusing a dirty large buf, clear its start */
378 memset(bigbuf, 0, sizeof(struct smb_hdr));
381 if (smallbuf == NULL) {
382 smallbuf = cifs_small_buf_get();
384 cERROR(1, ("No memory for SMB response"));
386 /* retry will check if exiting */
389 /* beginning of smb buffer is cleared in our buf_get */
390 } else /* if existing small buf clear beginning */
391 memset(smallbuf, 0, sizeof(struct smb_hdr));
395 smb_buffer = smallbuf;
396 iov.iov_base = smb_buffer;
398 smb_msg.msg_control = NULL;
399 smb_msg.msg_controllen = 0;
400 pdu_length = 4; /* enough to get RFC1001 header */
403 kernel_recvmsg(csocket, &smb_msg,
404 &iov, 1, pdu_length, 0 /* BB other flags? */);
406 if (kthread_should_stop()) {
408 } else if (server->tcpStatus == CifsNeedReconnect) {
409 cFYI(1, ("Reconnect after server stopped responding"));
410 cifs_reconnect(server);
411 cFYI(1, ("call to reconnect done"));
412 csocket = server->ssocket;
414 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
415 msleep(1); /* minimum sleep to prevent looping
416 allowing socket to clear and app threads to set
417 tcpStatus CifsNeedReconnect if server hung */
419 } else if (length <= 0) {
420 if (server->tcpStatus == CifsNew) {
421 cFYI(1, ("tcp session abend after SMBnegprot"));
422 /* some servers kill the TCP session rather than
423 returning an SMB negprot error, in which
424 case reconnecting here is not going to help,
425 and so simply return error to mount */
428 if (!try_to_freeze() && (length == -EINTR)) {
429 cFYI(1, ("cifsd thread killed"));
432 cFYI(1, ("Reconnect after unexpected peek error %d",
434 cifs_reconnect(server);
435 csocket = server->ssocket;
436 wake_up(&server->response_q);
438 } else if (length < 4) {
439 cFYI(1, ("less than four bytes received (%d bytes)",
441 pdu_length -= length;
446 /* The right amount was read from socket - 4 bytes */
447 /* so we can now interpret the length field */
449 /* the first byte big endian of the length field,
450 is actually not part of the length but the type
451 with the most common, zero, as regular data */
452 temp = *((char *) smb_buffer);
454 /* Note that FC 1001 length is big endian on the wire,
455 but we convert it here so it is always manipulated
456 as host byte order */
457 pdu_length = ntohl(smb_buffer->smb_buf_length);
458 smb_buffer->smb_buf_length = pdu_length;
460 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
462 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
464 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
465 cFYI(1, ("Good RFC 1002 session rsp"));
467 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
468 /* we get this from Windows 98 instead of
469 an error on SMB negprot response */
470 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
472 if (server->tcpStatus == CifsNew) {
473 /* if nack on negprot (rather than
474 ret of smb negprot error) reconnecting
475 not going to help, ret error to mount */
478 /* give server a second to
479 clean up before reconnect attempt */
481 /* always try 445 first on reconnect
482 since we get NACK on some if we ever
483 connected to port 139 (the NACK is
484 since we do not begin with RFC1001
485 session initialize frame) */
486 server->addr.sockAddr.sin_port =
488 cifs_reconnect(server);
489 csocket = server->ssocket;
490 wake_up(&server->response_q);
493 } else if (temp != (char) 0) {
494 cERROR(1, ("Unknown RFC 1002 frame"));
495 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
497 cifs_reconnect(server);
498 csocket = server->ssocket;
502 /* else we have an SMB response */
503 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
504 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
505 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
506 length, pdu_length+4));
507 cifs_reconnect(server);
508 csocket = server->ssocket;
509 wake_up(&server->response_q);
516 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
518 memcpy(bigbuf, smallbuf, 4);
522 iov.iov_base = 4 + (char *)smb_buffer;
523 iov.iov_len = pdu_length;
524 for (total_read = 0; total_read < pdu_length;
525 total_read += length) {
526 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
527 pdu_length - total_read, 0);
528 if (kthread_should_stop() ||
529 (length == -EINTR)) {
533 } else if (server->tcpStatus == CifsNeedReconnect) {
534 cifs_reconnect(server);
535 csocket = server->ssocket;
536 /* Reconnect wakes up rspns q */
537 /* Now we will reread sock */
540 } else if ((length == -ERESTARTSYS) ||
541 (length == -EAGAIN)) {
542 msleep(1); /* minimum sleep to prevent looping,
543 allowing socket to clear and app
544 threads to set tcpStatus
545 CifsNeedReconnect if server hung*/
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 = 1;
589 /* all parts received */
590 mid_entry->multiEnd = 1;
595 cERROR(1,("1st trans2 resp needs bigbuf"));
596 /* BB maybe we can fix this up, switch
597 to already allocated large buffer? */
599 /* Have first buffer */
600 mid_entry->resp_buf =
602 mid_entry->largeBuf = 1;
608 mid_entry->resp_buf = smb_buffer;
610 mid_entry->largeBuf = 1;
612 mid_entry->largeBuf = 0;
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) == FALSE)
638 && (isMultiRsp == FALSE)) {
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;
654 /* check if we have blocked requests that need to free */
655 /* Note that cifs_max_pending is normally 50, but
656 can be set at module install time to as little as two */
657 if (atomic_read(&server->inFlight) >= cifs_max_pending)
658 atomic_set(&server->inFlight, cifs_max_pending - 1);
659 /* We do not want to set the max_pending too low or we
660 could end up with the counter going negative */
661 spin_unlock(&GlobalMid_Lock);
662 /* Although there should not be any requests blocked on
663 this queue it can not hurt to be paranoid and try to wake up requests
664 that may haven been blocked when more than 50 at time were on the wire
665 to the same server - they now will see the session is in exit state
666 and get out of SendReceive. */
667 wake_up_all(&server->request_q);
668 /* give those requests time to exit */
671 if (server->ssocket) {
672 sock_release(csocket);
673 server->ssocket = NULL;
675 /* buffer usuallly freed in free_mid - need to free it here on exit */
676 cifs_buf_release(bigbuf);
677 if (smallbuf) /* no sense logging a debug message if NULL */
678 cifs_small_buf_release(smallbuf);
680 read_lock(&GlobalSMBSeslock);
681 if (list_empty(&server->pending_mid_q)) {
682 /* loop through server session structures attached to this and
684 list_for_each(tmp, &GlobalSMBSessionList) {
686 list_entry(tmp, struct cifsSesInfo,
688 if (ses->server == server) {
689 ses->status = CifsExiting;
693 read_unlock(&GlobalSMBSeslock);
695 /* although we can not zero the server struct pointer yet,
696 since there are active requests which may depnd on them,
697 mark the corresponding SMB sessions as exiting too */
698 list_for_each(tmp, &GlobalSMBSessionList) {
699 ses = list_entry(tmp, struct cifsSesInfo,
701 if (ses->server == server)
702 ses->status = CifsExiting;
705 spin_lock(&GlobalMid_Lock);
706 list_for_each(tmp, &server->pending_mid_q) {
707 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
708 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
709 cFYI(1, ("Clearing Mid 0x%x - waking up ",
711 task_to_wake = mid_entry->tsk;
713 wake_up_process(task_to_wake);
716 spin_unlock(&GlobalMid_Lock);
717 read_unlock(&GlobalSMBSeslock);
718 /* 1/8th of sec is more than enough time for them to exit */
722 if (!list_empty(&server->pending_mid_q)) {
723 /* mpx threads have not exited yet give them
724 at least the smb send timeout time for long ops */
725 /* due to delays on oplock break requests, we need
726 to wait at least 45 seconds before giving up
727 on a request getting a response and going ahead
729 cFYI(1, ("Wait for exit from demultiplex thread"));
731 /* if threads still have not exited they are probably never
732 coming home not much else we can do but free the memory */
735 write_lock(&GlobalSMBSeslock);
736 atomic_dec(&tcpSesAllocCount);
737 length = tcpSesAllocCount.counter;
739 /* last chance to mark ses pointers invalid
740 if there are any pointing to this (e.g
741 if a crazy root user tried to kill cifsd
742 kernel thread explicitly this might happen) */
743 list_for_each(tmp, &GlobalSMBSessionList) {
744 ses = list_entry(tmp, struct cifsSesInfo,
746 if (ses->server == server)
749 write_unlock(&GlobalSMBSeslock);
753 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
760 cifs_parse_mount_options(char *options, const char *devname,
765 unsigned int temp_len, i, j;
771 if (Local_System_Name[0] != 0)
772 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
774 char *nodename = utsname()->nodename;
775 int n = strnlen(nodename, 15);
776 memset(vol->source_rfc1001_name, 0x20, 15);
777 for (i = 0; i < n; i++) {
778 /* does not have to be perfect mapping since field is
779 informational, only used for servers that do not support
780 port 445 and it can be overridden at mount time */
781 vol->source_rfc1001_name[i] = toupper(nodename[i]);
784 vol->source_rfc1001_name[15] = 0;
785 /* null target name indicates to use *SMBSERVR default called name
786 if we end up sending RFC1001 session initialize */
787 vol->target_rfc1001_name[0] = 0;
788 vol->linux_uid = current->uid; /* current->euid instead? */
789 vol->linux_gid = current->gid;
790 vol->dir_mode = S_IRWXUGO;
791 /* 2767 perms indicate mandatory locking support */
792 vol->file_mode = S_IALLUGO & ~(S_ISUID | S_IXGRP);
794 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
796 /* default is always to request posix paths. */
797 vol->posix_paths = 1;
802 if (strncmp(options, "sep=", 4) == 0) {
803 if (options[4] != 0) {
804 separator[0] = options[4];
807 cFYI(1, ("Null separator not allowed"));
811 while ((data = strsep(&options, separator)) != NULL) {
814 if ((value = strchr(data, '=')) != NULL)
817 /* Have to parse this before we parse for "user" */
818 if (strnicmp(data, "user_xattr", 10) == 0) {
820 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
822 } else if (strnicmp(data, "user", 4) == 0) {
825 "CIFS: invalid or missing username\n");
826 return 1; /* needs_arg; */
827 } else if (!*value) {
828 /* null user, ie anonymous, authentication */
831 if (strnlen(value, 200) < 200) {
832 vol->username = value;
834 printk(KERN_WARNING "CIFS: username too long\n");
837 } else if (strnicmp(data, "pass", 4) == 0) {
839 vol->password = NULL;
841 } else if (value[0] == 0) {
842 /* check if string begins with double comma
843 since that would mean the password really
844 does start with a comma, and would not
845 indicate an empty string */
846 if (value[1] != separator[0]) {
847 vol->password = NULL;
851 temp_len = strlen(value);
852 /* removed password length check, NTLM passwords
853 can be arbitrarily long */
855 /* if comma in password, the string will be
856 prematurely null terminated. Commas in password are
857 specified across the cifs mount interface by a double
858 comma ie ,, and a comma used as in other cases ie ','
859 as a parameter delimiter/separator is single and due
860 to the strsep above is temporarily zeroed. */
862 /* NB: password legally can have multiple commas and
863 the only illegal character in a password is null */
865 if ((value[temp_len] == 0) &&
866 (value[temp_len+1] == separator[0])) {
868 value[temp_len] = separator[0];
869 temp_len += 2; /* move after second comma */
870 while (value[temp_len] != 0) {
871 if (value[temp_len] == separator[0]) {
872 if (value[temp_len+1] ==
874 /* skip second comma */
877 /* single comma indicating start
884 if (value[temp_len] == 0) {
888 /* point option to start of next parm */
889 options = value + temp_len + 1;
891 /* go from value to value + temp_len condensing
892 double commas to singles. Note that this ends up
893 allocating a few bytes too many, which is ok */
894 vol->password = kzalloc(temp_len, GFP_KERNEL);
895 if (vol->password == NULL) {
896 printk(KERN_WARNING "CIFS: no memory "
900 for (i = 0, j = 0; i < temp_len; i++, j++) {
901 vol->password[j] = value[i];
902 if (value[i] == separator[0]
903 && value[i+1] == separator[0]) {
904 /* skip second comma */
908 vol->password[j] = 0;
910 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
911 if (vol->password == NULL) {
912 printk(KERN_WARNING "CIFS: no memory "
916 strcpy(vol->password, value);
918 } else if (strnicmp(data, "ip", 2) == 0) {
919 if (!value || !*value) {
921 } else if (strnlen(value, 35) < 35) {
924 printk(KERN_WARNING "CIFS: ip address "
928 } else if (strnicmp(data, "sec", 3) == 0) {
929 if (!value || !*value) {
930 cERROR(1, ("no security value specified"));
932 } else if (strnicmp(value, "krb5i", 5) == 0) {
933 vol->secFlg |= CIFSSEC_MAY_KRB5 |
935 } else if (strnicmp(value, "krb5p", 5) == 0) {
936 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
938 cERROR(1, ("Krb5 cifs privacy not supported"));
940 } else if (strnicmp(value, "krb5", 4) == 0) {
941 vol->secFlg |= CIFSSEC_MAY_KRB5;
942 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
943 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
945 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
946 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
947 } else if (strnicmp(value, "ntlmi", 5) == 0) {
948 vol->secFlg |= CIFSSEC_MAY_NTLM |
950 } else if (strnicmp(value, "ntlm", 4) == 0) {
951 /* ntlm is default so can be turned off too */
952 vol->secFlg |= CIFSSEC_MAY_NTLM;
953 } else if (strnicmp(value, "nontlm", 6) == 0) {
954 /* BB is there a better way to do this? */
955 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
956 #ifdef CONFIG_CIFS_WEAK_PW_HASH
957 } else if (strnicmp(value, "lanman", 6) == 0) {
958 vol->secFlg |= CIFSSEC_MAY_LANMAN;
960 } else if (strnicmp(value, "none", 4) == 0) {
963 cERROR(1, ("bad security option: %s", value));
966 } else if ((strnicmp(data, "unc", 3) == 0)
967 || (strnicmp(data, "target", 6) == 0)
968 || (strnicmp(data, "path", 4) == 0)) {
969 if (!value || !*value) {
970 printk(KERN_WARNING "CIFS: invalid path to "
971 "network resource\n");
972 return 1; /* needs_arg; */
974 if ((temp_len = strnlen(value, 300)) < 300) {
975 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
976 if (vol->UNC == NULL)
978 strcpy(vol->UNC, value);
979 if (strncmp(vol->UNC, "//", 2) == 0) {
982 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
984 "CIFS: UNC Path does not begin "
985 "with // or \\\\ \n");
989 printk(KERN_WARNING "CIFS: UNC name too long\n");
992 } else if ((strnicmp(data, "domain", 3) == 0)
993 || (strnicmp(data, "workgroup", 5) == 0)) {
994 if (!value || !*value) {
995 printk(KERN_WARNING "CIFS: invalid domain name\n");
996 return 1; /* needs_arg; */
998 /* BB are there cases in which a comma can be valid in
999 a domain name and need special handling? */
1000 if (strnlen(value, 256) < 256) {
1001 vol->domainname = value;
1002 cFYI(1, ("Domain name set"));
1004 printk(KERN_WARNING "CIFS: domain name too "
1008 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1009 if (!value || !*value) {
1011 "CIFS: invalid path prefix\n");
1012 return 1; /* needs_argument */
1014 if ((temp_len = strnlen(value, 1024)) < 1024) {
1015 if (value[0] != '/')
1016 temp_len++; /* missing leading slash */
1017 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1018 if (vol->prepath == NULL)
1020 if (value[0] != '/') {
1021 vol->prepath[0] = '/';
1022 strcpy(vol->prepath+1, value);
1024 strcpy(vol->prepath, value);
1025 cFYI(1, ("prefix path %s", vol->prepath));
1027 printk(KERN_WARNING "CIFS: prefix too long\n");
1030 } else if (strnicmp(data, "iocharset", 9) == 0) {
1031 if (!value || !*value) {
1032 printk(KERN_WARNING "CIFS: invalid iocharset "
1034 return 1; /* needs_arg; */
1036 if (strnlen(value, 65) < 65) {
1037 if (strnicmp(value, "default", 7))
1038 vol->iocharset = value;
1039 /* if iocharset not set then load_nls_default
1040 is used by caller */
1041 cFYI(1, ("iocharset set to %s", value));
1043 printk(KERN_WARNING "CIFS: iocharset name "
1047 } else if (strnicmp(data, "uid", 3) == 0) {
1048 if (value && *value) {
1050 simple_strtoul(value, &value, 0);
1051 vol->override_uid = 1;
1053 } else if (strnicmp(data, "gid", 3) == 0) {
1054 if (value && *value) {
1056 simple_strtoul(value, &value, 0);
1057 vol->override_gid = 1;
1059 } else if (strnicmp(data, "file_mode", 4) == 0) {
1060 if (value && *value) {
1062 simple_strtoul(value, &value, 0);
1064 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1065 if (value && *value) {
1067 simple_strtoul(value, &value, 0);
1069 } else if (strnicmp(data, "dirmode", 4) == 0) {
1070 if (value && *value) {
1072 simple_strtoul(value, &value, 0);
1074 } else if (strnicmp(data, "port", 4) == 0) {
1075 if (value && *value) {
1077 simple_strtoul(value, &value, 0);
1079 } else if (strnicmp(data, "rsize", 5) == 0) {
1080 if (value && *value) {
1082 simple_strtoul(value, &value, 0);
1084 } else if (strnicmp(data, "wsize", 5) == 0) {
1085 if (value && *value) {
1087 simple_strtoul(value, &value, 0);
1089 } else if (strnicmp(data, "sockopt", 5) == 0) {
1090 if (value && *value) {
1092 simple_strtoul(value, &value, 0);
1094 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1095 if (!value || !*value || (*value == ' ')) {
1096 cFYI(1, ("invalid (empty) netbiosname"));
1098 memset(vol->source_rfc1001_name, 0x20, 15);
1099 for (i = 0; i < 15; i++) {
1100 /* BB are there cases in which a comma can be
1101 valid in this workstation netbios name (and need
1102 special handling)? */
1104 /* We do not uppercase netbiosname for user */
1108 vol->source_rfc1001_name[i] =
1111 /* The string has 16th byte zero still from
1112 set at top of the function */
1113 if ((i == 15) && (value[i] != 0))
1114 printk(KERN_WARNING "CIFS: netbiosname"
1115 " longer than 15 truncated.\n");
1117 } else if (strnicmp(data, "servern", 7) == 0) {
1118 /* servernetbiosname specified override *SMBSERVER */
1119 if (!value || !*value || (*value == ' ')) {
1120 cFYI(1, ("empty server netbiosname specified"));
1122 /* last byte, type, is 0x20 for servr type */
1123 memset(vol->target_rfc1001_name, 0x20, 16);
1125 for (i = 0; i < 15; i++) {
1126 /* BB are there cases in which a comma can be
1127 valid in this workstation netbios name
1128 (and need special handling)? */
1130 /* user or mount helper must uppercase
1135 vol->target_rfc1001_name[i] =
1138 /* The string has 16th byte zero still from
1139 set at top of the function */
1140 if ((i == 15) && (value[i] != 0))
1141 printk(KERN_WARNING "CIFS: server net"
1142 "biosname longer than 15 truncated.\n");
1144 } else if (strnicmp(data, "credentials", 4) == 0) {
1146 } else if (strnicmp(data, "version", 3) == 0) {
1148 } else if (strnicmp(data, "guest", 5) == 0) {
1150 } else if (strnicmp(data, "rw", 2) == 0) {
1152 } else if ((strnicmp(data, "suid", 4) == 0) ||
1153 (strnicmp(data, "nosuid", 6) == 0) ||
1154 (strnicmp(data, "exec", 4) == 0) ||
1155 (strnicmp(data, "noexec", 6) == 0) ||
1156 (strnicmp(data, "nodev", 5) == 0) ||
1157 (strnicmp(data, "noauto", 6) == 0) ||
1158 (strnicmp(data, "dev", 3) == 0)) {
1159 /* The mount tool or mount.cifs helper (if present)
1160 uses these opts to set flags, and the flags are read
1161 by the kernel vfs layer before we get here (ie
1162 before read super) so there is no point trying to
1163 parse these options again and set anything and it
1164 is ok to just ignore them */
1166 } else if (strnicmp(data, "ro", 2) == 0) {
1168 } else if (strnicmp(data, "hard", 4) == 0) {
1170 } else if (strnicmp(data, "soft", 4) == 0) {
1172 } else if (strnicmp(data, "perm", 4) == 0) {
1174 } else if (strnicmp(data, "noperm", 6) == 0) {
1176 } else if (strnicmp(data, "mapchars", 8) == 0) {
1178 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1180 } else if (strnicmp(data, "sfu", 3) == 0) {
1182 } else if (strnicmp(data, "nosfu", 5) == 0) {
1184 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1185 vol->posix_paths = 1;
1186 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1187 vol->posix_paths = 0;
1188 } else if (strnicmp(data, "nounix", 6) == 0) {
1189 vol->no_linux_ext = 1;
1190 } else if (strnicmp(data, "nolinux", 7) == 0) {
1191 vol->no_linux_ext = 1;
1192 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1193 (strnicmp(data, "ignorecase", 10) == 0)) {
1195 } else if (strnicmp(data, "brl", 3) == 0) {
1197 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1198 (strnicmp(data, "nolock", 6) == 0)) {
1200 /* turn off mandatory locking in mode
1201 if remote locking is turned off since the
1202 local vfs will do advisory */
1203 if (vol->file_mode ==
1204 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1205 vol->file_mode = S_IALLUGO;
1206 } else if (strnicmp(data, "setuids", 7) == 0) {
1208 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1210 } else if (strnicmp(data, "nohard", 6) == 0) {
1212 } else if (strnicmp(data, "nosoft", 6) == 0) {
1214 } else if (strnicmp(data, "nointr", 6) == 0) {
1216 } else if (strnicmp(data, "intr", 4) == 0) {
1218 } else if (strnicmp(data, "serverino", 7) == 0) {
1219 vol->server_ino = 1;
1220 } else if (strnicmp(data, "noserverino", 9) == 0) {
1221 vol->server_ino = 0;
1222 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1224 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1226 } else if (strnicmp(data, "acl", 3) == 0) {
1227 vol->no_psx_acl = 0;
1228 } else if (strnicmp(data, "noacl", 5) == 0) {
1229 vol->no_psx_acl = 1;
1230 } else if (strnicmp(data, "sign", 4) == 0) {
1231 vol->secFlg |= CIFSSEC_MUST_SIGN;
1232 /* } else if (strnicmp(data, "seal",4) == 0) {
1233 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1234 } else if (strnicmp(data, "direct", 6) == 0) {
1236 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1238 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1239 if (!value || !*value) {
1240 vol->in6_addr = NULL;
1241 } else if (strnlen(value, 49) == 48) {
1242 vol->in6_addr = value;
1244 printk(KERN_WARNING "CIFS: ip v6 address not "
1245 "48 characters long\n");
1248 } else if (strnicmp(data, "noac", 4) == 0) {
1249 printk(KERN_WARNING "CIFS: Mount option noac not "
1250 "supported. Instead set "
1251 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1253 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1256 if (vol->UNC == NULL) {
1257 if (devname == NULL) {
1258 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1262 if ((temp_len = strnlen(devname, 300)) < 300) {
1263 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1264 if (vol->UNC == NULL)
1266 strcpy(vol->UNC, devname);
1267 if (strncmp(vol->UNC, "//", 2) == 0) {
1270 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1271 printk(KERN_WARNING "CIFS: UNC Path does not "
1272 "begin with // or \\\\ \n");
1276 printk(KERN_WARNING "CIFS: UNC name too long\n");
1280 if (vol->UNCip == NULL)
1281 vol->UNCip = &vol->UNC[2];
1286 static struct cifsSesInfo *
1287 cifs_find_tcp_session(struct in_addr *target_ip_addr,
1288 struct in6_addr *target_ip6_addr,
1289 char *userName, struct TCP_Server_Info **psrvTcp)
1291 struct list_head *tmp;
1292 struct cifsSesInfo *ses;
1294 read_lock(&GlobalSMBSeslock);
1296 list_for_each(tmp, &GlobalSMBSessionList) {
1297 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1299 if ((target_ip_addr &&
1300 (ses->server->addr.sockAddr.sin_addr.s_addr
1301 == target_ip_addr->s_addr)) || (target_ip6_addr
1302 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1303 target_ip6_addr, sizeof(*target_ip6_addr)))) {
1304 /* BB lock server and tcp session and increment
1307 /* found a match on the TCP session */
1308 *psrvTcp = ses->server;
1310 /* BB check if reconnection needed */
1312 (ses->userName, userName,
1313 MAX_USERNAME_SIZE) == 0){
1314 read_unlock(&GlobalSMBSeslock);
1315 /* Found exact match on both TCP and
1321 /* else tcp and smb sessions need reconnection */
1323 read_unlock(&GlobalSMBSeslock);
1327 static struct cifsTconInfo *
1328 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1330 struct list_head *tmp;
1331 struct cifsTconInfo *tcon;
1333 read_lock(&GlobalSMBSeslock);
1334 list_for_each(tmp, &GlobalTreeConnectionList) {
1335 cFYI(1, ("Next tcon"));
1336 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1338 if (tcon->ses->server) {
1340 ("old ip addr: %x == new ip %x ?",
1341 tcon->ses->server->addr.sockAddr.sin_addr.
1342 s_addr, new_target_ip_addr));
1343 if (tcon->ses->server->addr.sockAddr.sin_addr.
1344 s_addr == new_target_ip_addr) {
1345 /* BB lock tcon, server and tcp session and increment use count here? */
1346 /* found a match on the TCP session */
1347 /* BB check if reconnection needed */
1349 ("IP match, old UNC: %s new: %s",
1350 tcon->treeName, uncName));
1352 (tcon->treeName, uncName,
1353 MAX_TREE_SIZE) == 0) {
1355 ("and old usr: %s new: %s",
1356 tcon->treeName, uncName));
1358 (tcon->ses->userName,
1360 MAX_USERNAME_SIZE) == 0) {
1361 read_unlock(&GlobalSMBSeslock);
1362 /* matched smb session
1371 read_unlock(&GlobalSMBSeslock);
1376 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1377 const char *old_path, const struct nls_table *nls_codepage,
1380 unsigned char *referrals = NULL;
1381 unsigned int num_referrals;
1384 rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
1385 &num_referrals, &referrals, remap);
1387 /* BB Add in code to: if valid refrl, if not ip address contact
1388 the helper that resolves tcp names, mount to it, try to
1389 tcon to it unmount it if fail */
1397 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1398 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1399 unsigned char **preferrals, int remap)
1404 *pnum_referrals = 0;
1406 if (pSesInfo->ipc_tid == 0) {
1407 temp_unc = kmalloc(2 /* for slashes */ +
1408 strnlen(pSesInfo->serverName,
1409 SERVER_NAME_LEN_WITH_NULL * 2)
1410 + 1 + 4 /* slash IPC$ */ + 2,
1412 if (temp_unc == NULL)
1416 strcpy(temp_unc + 2, pSesInfo->serverName);
1417 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1418 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1420 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1424 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1425 pnum_referrals, nls_codepage, remap);
1430 /* See RFC1001 section 14 on representation of Netbios names */
1431 static void rfc1002mangle(char *target, char *source, unsigned int length)
1435 for (i = 0, j = 0; i < (length); i++) {
1436 /* mask a nibble at a time and encode */
1437 target[j] = 'A' + (0x0F & (source[i] >> 4));
1438 target[j+1] = 'A' + (0x0F & source[i]);
1446 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1447 char *netbios_name, char *target_name)
1451 __be16 orig_port = 0;
1453 if (*csocket == NULL) {
1454 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1455 IPPROTO_TCP, csocket);
1457 cERROR(1, ("Error %d creating socket", rc));
1461 /* BB other socket options to set KEEPALIVE, NODELAY? */
1462 cFYI(1, ("Socket created"));
1463 (*csocket)->sk->sk_allocation = GFP_NOFS;
1467 psin_server->sin_family = AF_INET;
1468 if (psin_server->sin_port) { /* user overrode default port */
1469 rc = (*csocket)->ops->connect(*csocket,
1470 (struct sockaddr *) psin_server,
1471 sizeof (struct sockaddr_in), 0);
1477 /* save original port so we can retry user specified port
1478 later if fall back ports fail this time */
1479 orig_port = psin_server->sin_port;
1481 /* do not retry on the same port we just failed on */
1482 if (psin_server->sin_port != htons(CIFS_PORT)) {
1483 psin_server->sin_port = htons(CIFS_PORT);
1485 rc = (*csocket)->ops->connect(*csocket,
1486 (struct sockaddr *) psin_server,
1487 sizeof (struct sockaddr_in), 0);
1493 psin_server->sin_port = htons(RFC1001_PORT);
1494 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1496 sizeof (struct sockaddr_in), 0);
1501 /* give up here - unless we want to retry on different
1502 protocol families some day */
1505 psin_server->sin_port = orig_port;
1506 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1507 sock_release(*csocket);
1511 /* Eventually check for other socket options to change from
1512 the default. sock_setsockopt not used because it expects
1513 user space buffer */
1514 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1515 (*csocket)->sk->sk_sndbuf,
1516 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1517 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1518 /* make the bufsizes depend on wsize/rsize and max requests */
1519 if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
1520 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1521 if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1522 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1524 /* send RFC1001 sessinit */
1525 if (psin_server->sin_port == htons(RFC1001_PORT)) {
1526 /* some servers require RFC1001 sessinit before sending
1527 negprot - BB check reconnection in case where second
1528 sessinit is sent but no second negprot */
1529 struct rfc1002_session_packet *ses_init_buf;
1530 struct smb_hdr *smb_buf;
1531 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1534 ses_init_buf->trailer.session_req.called_len = 32;
1535 if (target_name && (target_name[0] != 0)) {
1536 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1539 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1540 DEFAULT_CIFS_CALLED_NAME, 16);
1543 ses_init_buf->trailer.session_req.calling_len = 32;
1544 /* calling name ends in null (byte 16) from old smb
1546 if (netbios_name && (netbios_name[0] != 0)) {
1547 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1550 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1551 "LINUX_CIFS_CLNT", 16);
1553 ses_init_buf->trailer.session_req.scope1 = 0;
1554 ses_init_buf->trailer.session_req.scope2 = 0;
1555 smb_buf = (struct smb_hdr *)ses_init_buf;
1556 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1557 smb_buf->smb_buf_length = 0x81000044;
1558 rc = smb_send(*csocket, smb_buf, 0x44,
1559 (struct sockaddr *)psin_server);
1560 kfree(ses_init_buf);
1561 msleep(1); /* RFC1001 layer in at least one server
1562 requires very short break before negprot
1563 presumably because not expecting negprot
1564 to follow so fast. This is a simple
1565 solution that works without
1566 complicating the code and causes no
1567 significant slowing down on mount
1568 for everyone else */
1570 /* else the negprot may still work without this
1571 even though malloc failed */
1579 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1583 __be16 orig_port = 0;
1585 if (*csocket == NULL) {
1586 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1587 IPPROTO_TCP, csocket);
1589 cERROR(1, ("Error %d creating ipv6 socket", rc));
1593 /* BB other socket options to set KEEPALIVE, NODELAY? */
1594 cFYI(1, ("ipv6 Socket created"));
1595 (*csocket)->sk->sk_allocation = GFP_NOFS;
1599 psin_server->sin6_family = AF_INET6;
1601 if (psin_server->sin6_port) { /* user overrode default port */
1602 rc = (*csocket)->ops->connect(*csocket,
1603 (struct sockaddr *) psin_server,
1604 sizeof (struct sockaddr_in6), 0);
1610 /* save original port so we can retry user specified port
1611 later if fall back ports fail this time */
1613 orig_port = psin_server->sin6_port;
1614 /* do not retry on the same port we just failed on */
1615 if (psin_server->sin6_port != htons(CIFS_PORT)) {
1616 psin_server->sin6_port = htons(CIFS_PORT);
1618 rc = (*csocket)->ops->connect(*csocket,
1619 (struct sockaddr *) psin_server,
1620 sizeof (struct sockaddr_in6), 0);
1626 psin_server->sin6_port = htons(RFC1001_PORT);
1627 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1628 psin_server, sizeof (struct sockaddr_in6), 0);
1633 /* give up here - unless we want to retry on different
1634 protocol families some day */
1637 psin_server->sin6_port = orig_port;
1638 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1639 sock_release(*csocket);
1643 /* Eventually check for other socket options to change from
1644 the default. sock_setsockopt not used because it expects
1645 user space buffer */
1646 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1651 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1652 struct super_block *sb, struct smb_vol *vol_info)
1654 /* if we are reconnecting then should we check to see if
1655 * any requested capabilities changed locally e.g. via
1656 * remount but we can not do much about it here
1657 * if they have (even if we could detect it by the following)
1658 * Perhaps we could add a backpointer to array of sb from tcon
1659 * or if we change to make all sb to same share the same
1660 * sb as NFS - then we only have one backpointer to sb.
1661 * What if we wanted to mount the server share twice once with
1662 * and once without posixacls or posix paths? */
1663 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1665 if (vol_info && vol_info->no_linux_ext) {
1666 tcon->fsUnixInfo.Capability = 0;
1667 tcon->unix_ext = 0; /* Unix Extensions disabled */
1668 cFYI(1, ("Linux protocol extensions disabled"));
1670 } else if (vol_info)
1671 tcon->unix_ext = 1; /* Unix Extensions supported */
1673 if (tcon->unix_ext == 0) {
1674 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1678 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1679 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1681 /* check for reconnect case in which we do not
1682 want to change the mount behavior if we can avoid it */
1683 if (vol_info == NULL) {
1684 /* turn off POSIX ACL and PATHNAMES if not set
1685 originally at mount time */
1686 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1687 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1688 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
1689 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1692 cap &= CIFS_UNIX_CAP_MASK;
1693 if (vol_info && vol_info->no_psx_acl)
1694 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1695 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
1696 cFYI(1, ("negotiated posix acl support"));
1698 sb->s_flags |= MS_POSIXACL;
1701 if (vol_info && vol_info->posix_paths == 0)
1702 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1703 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1704 cFYI(1, ("negotiate posix pathnames"));
1706 CIFS_SB(sb)->mnt_cifs_flags |=
1707 CIFS_MOUNT_POSIX_PATHS;
1710 /* We might be setting the path sep back to a different
1711 form if we are reconnecting and the server switched its
1712 posix path capability for this share */
1713 if (sb && (CIFS_SB(sb)->prepathlen > 0))
1714 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1716 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
1717 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
1718 CIFS_SB(sb)->rsize = 127 * 1024;
1719 #ifdef CONFIG_CIFS_DEBUG2
1720 cFYI(1, ("larger reads not supported by srv"));
1726 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
1727 #ifdef CONFIG_CIFS_DEBUG2
1728 if (cap & CIFS_UNIX_FCNTL_CAP)
1729 cFYI(1, ("FCNTL cap"));
1730 if (cap & CIFS_UNIX_EXTATTR_CAP)
1731 cFYI(1, ("EXTATTR cap"));
1732 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1733 cFYI(1, ("POSIX path cap"));
1734 if (cap & CIFS_UNIX_XATTR_CAP)
1735 cFYI(1, ("XATTR cap"));
1736 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
1737 cFYI(1, ("POSIX ACL cap"));
1738 if (cap & CIFS_UNIX_LARGE_READ_CAP)
1739 cFYI(1, ("very large read cap"));
1740 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
1741 cFYI(1, ("very large write cap"));
1742 #endif /* CIFS_DEBUG2 */
1743 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1744 if (vol_info == NULL) {
1745 cFYI(1, ("resetting capabilities failed"));
1747 cERROR(1, ("Negotiating Unix capabilities "
1748 "with the server failed. Consider "
1749 "mounting with the Unix Extensions\n"
1750 "disabled, if problems are found, "
1751 "by specifying the nounix mount "
1759 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1760 char *mount_data, const char *devname)
1764 int address_type = AF_INET;
1765 struct socket *csocket = NULL;
1766 struct sockaddr_in sin_server;
1767 struct sockaddr_in6 sin_server6;
1768 struct smb_vol volume_info;
1769 struct cifsSesInfo *pSesInfo = NULL;
1770 struct cifsSesInfo *existingCifsSes = NULL;
1771 struct cifsTconInfo *tcon = NULL;
1772 struct TCP_Server_Info *srvTcp = NULL;
1776 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1778 memset(&volume_info, 0, sizeof(struct smb_vol));
1779 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1780 kfree(volume_info.UNC);
1781 kfree(volume_info.password);
1782 kfree(volume_info.prepath);
1787 if (volume_info.nullauth) {
1788 cFYI(1, ("null user"));
1789 volume_info.username = NULL;
1790 } else if (volume_info.username) {
1791 /* BB fixme parse for domain name here */
1792 cFYI(1, ("Username: %s", volume_info.username));
1794 cifserror("No username specified");
1795 /* In userspace mount helper we can get user name from alternate
1796 locations such as env variables and files on disk */
1797 kfree(volume_info.UNC);
1798 kfree(volume_info.password);
1799 kfree(volume_info.prepath);
1804 if (volume_info.UNCip && volume_info.UNC) {
1805 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,
1806 &sin_server.sin_addr.s_addr);
1809 /* not ipv4 address, try ipv6 */
1810 rc = cifs_inet_pton(AF_INET6, volume_info.UNCip,
1811 &sin_server6.sin6_addr.in6_u);
1813 address_type = AF_INET6;
1815 address_type = AF_INET;
1819 /* we failed translating address */
1820 kfree(volume_info.UNC);
1821 kfree(volume_info.password);
1822 kfree(volume_info.prepath);
1827 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1830 } else if (volume_info.UNCip) {
1831 /* BB using ip addr as server name to connect to the
1833 cERROR(1, ("Connecting to DFS root not implemented yet"));
1834 kfree(volume_info.UNC);
1835 kfree(volume_info.password);
1836 kfree(volume_info.prepath);
1839 } else /* which servers DFS root would we conect to */ {
1841 ("CIFS mount error: No UNC path (e.g. -o "
1842 "unc=//192.168.1.100/public) specified"));
1843 kfree(volume_info.UNC);
1844 kfree(volume_info.password);
1845 kfree(volume_info.prepath);
1850 /* this is needed for ASCII cp to Unicode converts */
1851 if (volume_info.iocharset == NULL) {
1852 cifs_sb->local_nls = load_nls_default();
1853 /* load_nls_default can not return null */
1855 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1856 if (cifs_sb->local_nls == NULL) {
1857 cERROR(1, ("CIFS mount error: iocharset %s not found",
1858 volume_info.iocharset));
1859 kfree(volume_info.UNC);
1860 kfree(volume_info.password);
1861 kfree(volume_info.prepath);
1867 if (address_type == AF_INET)
1868 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1869 NULL /* no ipv6 addr */,
1870 volume_info.username, &srvTcp);
1871 else if (address_type == AF_INET6) {
1872 cFYI(1, ("looking for ipv6 address"));
1873 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1874 &sin_server6.sin6_addr,
1875 volume_info.username, &srvTcp);
1877 kfree(volume_info.UNC);
1878 kfree(volume_info.password);
1879 kfree(volume_info.prepath);
1885 cFYI(1, ("Existing tcp session with server found"));
1886 } else { /* create socket */
1887 if (volume_info.port)
1888 sin_server.sin_port = htons(volume_info.port);
1890 sin_server.sin_port = 0;
1891 if (address_type == AF_INET6) {
1892 cFYI(1, ("attempting ipv6 connect"));
1893 /* BB should we allow ipv6 on port 139? */
1894 /* other OS never observed in Wild doing 139 with v6 */
1895 rc = ipv6_connect(&sin_server6, &csocket);
1897 rc = ipv4_connect(&sin_server, &csocket,
1898 volume_info.source_rfc1001_name,
1899 volume_info.target_rfc1001_name);
1901 cERROR(1, ("Error connecting to IPv4 socket. "
1902 "Aborting operation"));
1903 if (csocket != NULL)
1904 sock_release(csocket);
1905 kfree(volume_info.UNC);
1906 kfree(volume_info.password);
1907 kfree(volume_info.prepath);
1912 srvTcp = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1915 sock_release(csocket);
1916 kfree(volume_info.UNC);
1917 kfree(volume_info.password);
1918 kfree(volume_info.prepath);
1922 memcpy(&srvTcp->addr.sockAddr, &sin_server,
1923 sizeof (struct sockaddr_in));
1924 atomic_set(&srvTcp->inFlight, 0);
1925 /* BB Add code for ipv6 case too */
1926 srvTcp->ssocket = csocket;
1927 srvTcp->protocolType = IPV4;
1928 init_waitqueue_head(&srvTcp->response_q);
1929 init_waitqueue_head(&srvTcp->request_q);
1930 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1931 /* at this point we are the only ones with the pointer
1932 to the struct since the kernel thread not created yet
1933 so no need to spinlock this init of tcpStatus */
1934 srvTcp->tcpStatus = CifsNew;
1935 init_MUTEX(&srvTcp->tcpSem);
1936 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1937 if ( IS_ERR(srvTcp->tsk) ) {
1938 rc = PTR_ERR(srvTcp->tsk);
1939 cERROR(1, ("error %d create cifsd thread", rc));
1941 sock_release(csocket);
1942 kfree(volume_info.UNC);
1943 kfree(volume_info.password);
1944 kfree(volume_info.prepath);
1948 wait_for_completion(&cifsd_complete);
1950 memcpy(srvTcp->workstation_RFC1001_name,
1951 volume_info.source_rfc1001_name, 16);
1952 memcpy(srvTcp->server_RFC1001_name,
1953 volume_info.target_rfc1001_name, 16);
1954 srvTcp->sequence_number = 0;
1958 if (existingCifsSes) {
1959 pSesInfo = existingCifsSes;
1960 cFYI(1, ("Existing smb sess found"));
1961 kfree(volume_info.password);
1962 /* volume_info.UNC freed at end of function */
1964 cFYI(1, ("Existing smb sess not found"));
1965 pSesInfo = sesInfoAlloc();
1966 if (pSesInfo == NULL)
1969 pSesInfo->server = srvTcp;
1970 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
1971 NIPQUAD(sin_server.sin_addr.s_addr));
1975 /* volume_info.password freed at unmount */
1976 if (volume_info.password)
1977 pSesInfo->password = volume_info.password;
1978 if (volume_info.username)
1979 strncpy(pSesInfo->userName,
1980 volume_info.username,
1982 if (volume_info.domainname) {
1983 int len = strlen(volume_info.domainname);
1984 pSesInfo->domainName =
1985 kmalloc(len + 1, GFP_KERNEL);
1986 if (pSesInfo->domainName)
1987 strcpy(pSesInfo->domainName,
1988 volume_info.domainname);
1990 pSesInfo->linux_uid = volume_info.linux_uid;
1991 pSesInfo->overrideSecFlg = volume_info.secFlg;
1992 down(&pSesInfo->sesSem);
1993 /* BB FIXME need to pass vol->secFlgs BB */
1994 rc = cifs_setup_session(xid, pSesInfo,
1995 cifs_sb->local_nls);
1996 up(&pSesInfo->sesSem);
1998 atomic_inc(&srvTcp->socketUseCount);
2000 kfree(volume_info.password);
2003 /* search for existing tcon to this server share */
2005 if (volume_info.rsize > CIFSMaxBufSize) {
2006 cERROR(1, ("rsize %d too large, using MaxBufSize",
2007 volume_info.rsize));
2008 cifs_sb->rsize = CIFSMaxBufSize;
2009 } else if ((volume_info.rsize) &&
2010 (volume_info.rsize <= CIFSMaxBufSize))
2011 cifs_sb->rsize = volume_info.rsize;
2013 cifs_sb->rsize = CIFSMaxBufSize;
2015 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2016 cERROR(1, ("wsize %d too large, using 4096 instead",
2017 volume_info.wsize));
2018 cifs_sb->wsize = 4096;
2019 } else if (volume_info.wsize)
2020 cifs_sb->wsize = volume_info.wsize;
2023 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2025 /* old default of CIFSMaxBufSize was too small now
2026 that SMB Write2 can send multiple pages in kvec.
2027 RFC1001 does not describe what happens when frame
2028 bigger than 128K is sent so use that as max in
2029 conjunction with 52K kvec constraint on arch with 4K
2032 if (cifs_sb->rsize < 2048) {
2033 cifs_sb->rsize = 2048;
2034 /* Windows ME may prefer this */
2035 cFYI(1, ("readsize set to minimum: 2048"));
2037 /* calculate prepath */
2038 cifs_sb->prepath = volume_info.prepath;
2039 if (cifs_sb->prepath) {
2040 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2041 cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
2042 volume_info.prepath = NULL;
2044 cifs_sb->prepathlen = 0;
2045 cifs_sb->mnt_uid = volume_info.linux_uid;
2046 cifs_sb->mnt_gid = volume_info.linux_gid;
2047 cifs_sb->mnt_file_mode = volume_info.file_mode;
2048 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
2049 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2050 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2052 if (volume_info.noperm)
2053 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2054 if (volume_info.setuids)
2055 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2056 if (volume_info.server_ino)
2057 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2058 if (volume_info.remap)
2059 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2060 if (volume_info.no_xattr)
2061 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2062 if (volume_info.sfu_emul)
2063 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2064 if (volume_info.nobrl)
2065 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2066 if (volume_info.cifs_acl)
2067 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2068 if (volume_info.override_uid)
2069 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2070 if (volume_info.override_gid)
2071 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2072 if (volume_info.direct_io) {
2073 cFYI(1, ("mounting share using direct i/o"));
2074 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2078 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2079 volume_info.username);
2081 cFYI(1, ("Found match on UNC path"));
2082 /* we can have only one retry value for a connection
2083 to a share so for resources mounted more than once
2084 to the same server share the last value passed in
2085 for the retry flag is used */
2086 tcon->retry = volume_info.retry;
2087 tcon->nocase = volume_info.nocase;
2089 tcon = tconInfoAlloc();
2093 /* check for null share name ie connecting to
2096 /* BB check if this works for exactly length
2098 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2099 && (strchr(volume_info.UNC + 3, '/') ==
2101 rc = connect_to_dfs_path(xid, pSesInfo,
2102 "", cifs_sb->local_nls,
2103 cifs_sb->mnt_cifs_flags &
2104 CIFS_MOUNT_MAP_SPECIAL_CHR);
2105 kfree(volume_info.UNC);
2109 /* BB Do we need to wrap sesSem around
2110 * this TCon call and Unix SetFS as
2111 * we do on SessSetup and reconnect? */
2112 rc = CIFSTCon(xid, pSesInfo,
2114 tcon, cifs_sb->local_nls);
2115 cFYI(1, ("CIFS Tcon rc = %d", rc));
2118 atomic_inc(&pSesInfo->inUse);
2119 tcon->retry = volume_info.retry;
2120 tcon->nocase = volume_info.nocase;
2126 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2127 sb->s_maxbytes = (u64) 1 << 63;
2129 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2132 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2133 sb->s_time_gran = 100;
2135 /* on error free sesinfo and tcon struct if needed */
2137 /* if session setup failed, use count is zero but
2138 we still need to free cifsd thread */
2139 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2140 spin_lock(&GlobalMid_Lock);
2141 srvTcp->tcpStatus = CifsExiting;
2142 spin_unlock(&GlobalMid_Lock);
2144 struct task_struct *tsk;
2145 /* If we could verify that kthread_stop would
2146 always wake up processes blocked in
2147 tcp in recv_mesg then we could remove the
2149 force_sig(SIGKILL, srvTcp->tsk);
2155 /* If find_unc succeeded then rc == 0 so we can not end */
2156 if (tcon) /* up accidently freeing someone elses tcon struct */
2158 if (existingCifsSes == NULL) {
2160 if ((pSesInfo->server) &&
2161 (pSesInfo->status == CifsGood)) {
2163 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2164 /* if the socketUseCount is now zero */
2165 if ((temp_rc == -ESHUTDOWN) &&
2166 (pSesInfo->server) &&
2167 (pSesInfo->server->tsk)) {
2168 struct task_struct *tsk;
2170 pSesInfo->server->tsk);
2171 tsk = pSesInfo->server->tsk;
2176 cFYI(1, ("No session or bad tcon"));
2177 sesInfoFree(pSesInfo);
2178 /* pSesInfo = NULL; */
2182 atomic_inc(&tcon->useCount);
2183 cifs_sb->tcon = tcon;
2184 tcon->ses = pSesInfo;
2186 /* do not care if following two calls succeed - informational */
2188 CIFSSMBQFSDeviceInfo(xid, tcon);
2189 CIFSSMBQFSAttributeInfo(xid, tcon);
2192 /* tell server which Unix caps we support */
2193 if (tcon->ses->capabilities & CAP_UNIX)
2194 /* reset of caps checks mount to see if unix extensions
2195 disabled for just this mount */
2196 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2198 tcon->unix_ext = 0; /* server does not support them */
2200 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2201 cifs_sb->rsize = 1024 * 127;
2202 #ifdef CONFIG_CIFS_DEBUG2
2203 cFYI(1, ("no very large read support, rsize now 127K"));
2206 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2207 cifs_sb->wsize = min(cifs_sb->wsize,
2208 (tcon->ses->server->maxBuf -
2209 MAX_CIFS_HDR_SIZE));
2210 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2211 cifs_sb->rsize = min(cifs_sb->rsize,
2212 (tcon->ses->server->maxBuf -
2213 MAX_CIFS_HDR_SIZE));
2216 /* volume_info.password is freed above when existing session found
2217 (in which case it is not needed anymore) but when new sesion is created
2218 the password ptr is put in the new session structure (in which case the
2219 password will be freed at unmount time) */
2220 kfree(volume_info.UNC);
2221 kfree(volume_info.prepath);
2227 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2228 char session_key[CIFS_SESS_KEY_SIZE],
2229 const struct nls_table *nls_codepage)
2231 struct smb_hdr *smb_buffer;
2232 struct smb_hdr *smb_buffer_response;
2233 SESSION_SETUP_ANDX *pSMB;
2234 SESSION_SETUP_ANDX *pSMBr;
2239 int remaining_words = 0;
2240 int bytes_returned = 0;
2245 cFYI(1, ("In sesssetup"));
2248 user = ses->userName;
2249 domain = ses->domainName;
2250 smb_buffer = cifs_buf_get();
2251 if (smb_buffer == NULL) {
2254 smb_buffer_response = smb_buffer;
2255 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2257 /* send SMBsessionSetup here */
2258 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2259 NULL /* no tCon exists yet */ , 13 /* wct */ );
2261 smb_buffer->Mid = GetNextMid(ses->server);
2262 pSMB->req_no_secext.AndXCommand = 0xFF;
2263 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2264 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2266 if (ses->server->secMode &
2267 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2268 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2270 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2271 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2272 if (ses->capabilities & CAP_UNICODE) {
2273 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2274 capabilities |= CAP_UNICODE;
2276 if (ses->capabilities & CAP_STATUS32) {
2277 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2278 capabilities |= CAP_STATUS32;
2280 if (ses->capabilities & CAP_DFS) {
2281 smb_buffer->Flags2 |= SMBFLG2_DFS;
2282 capabilities |= CAP_DFS;
2284 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2286 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2287 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2289 pSMB->req_no_secext.CaseSensitivePasswordLength =
2290 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2291 bcc_ptr = pByteArea(smb_buffer);
2292 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2293 bcc_ptr += CIFS_SESS_KEY_SIZE;
2294 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2295 bcc_ptr += CIFS_SESS_KEY_SIZE;
2297 if (ses->capabilities & CAP_UNICODE) {
2298 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2303 bytes_returned = 0; /* skip null user */
2306 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2308 /* convert number of 16 bit words to bytes */
2309 bcc_ptr += 2 * bytes_returned;
2310 bcc_ptr += 2; /* trailing null */
2313 cifs_strtoUCS((__le16 *) bcc_ptr,
2314 "CIFS_LINUX_DOM", 32, nls_codepage);
2317 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2319 bcc_ptr += 2 * bytes_returned;
2322 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2324 bcc_ptr += 2 * bytes_returned;
2326 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2328 bcc_ptr += 2 * bytes_returned;
2331 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2333 bcc_ptr += 2 * bytes_returned;
2337 strncpy(bcc_ptr, user, 200);
2338 bcc_ptr += strnlen(user, 200);
2342 if (domain == NULL) {
2343 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2344 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2346 strncpy(bcc_ptr, domain, 64);
2347 bcc_ptr += strnlen(domain, 64);
2351 strcpy(bcc_ptr, "Linux version ");
2352 bcc_ptr += strlen("Linux version ");
2353 strcpy(bcc_ptr, utsname()->release);
2354 bcc_ptr += strlen(utsname()->release) + 1;
2355 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2356 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2358 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2359 smb_buffer->smb_buf_length += count;
2360 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2362 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2363 &bytes_returned, 1);
2365 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2366 } else if ((smb_buffer_response->WordCount == 3)
2367 || (smb_buffer_response->WordCount == 4)) {
2368 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2369 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2370 if (action & GUEST_LOGIN)
2371 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
2372 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format
2374 cFYI(1, ("UID = %d ", ses->Suid));
2375 /* response can have either 3 or 4 word count - Samba sends 3 */
2376 bcc_ptr = pByteArea(smb_buffer_response);
2377 if ((pSMBr->resp.hdr.WordCount == 3)
2378 || ((pSMBr->resp.hdr.WordCount == 4)
2379 && (blob_len < pSMBr->resp.ByteCount))) {
2380 if (pSMBr->resp.hdr.WordCount == 4)
2381 bcc_ptr += blob_len;
2383 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2384 if ((long) (bcc_ptr) % 2) {
2386 (BCC(smb_buffer_response) - 1) / 2;
2387 /* Unicode strings must be word
2392 BCC(smb_buffer_response) / 2;
2395 UniStrnlen((wchar_t *) bcc_ptr,
2396 remaining_words - 1);
2397 /* We look for obvious messed up bcc or strings in response so we do not go off
2398 the end since (at least) WIN2K and Windows XP have a major bug in not null
2399 terminating last Unicode string in response */
2401 kfree(ses->serverOS);
2402 ses->serverOS = kzalloc(2 * (len + 1),
2404 if (ses->serverOS == NULL)
2405 goto sesssetup_nomem;
2406 cifs_strfromUCS_le(ses->serverOS,
2409 bcc_ptr += 2 * (len + 1);
2410 remaining_words -= len + 1;
2411 ses->serverOS[2 * len] = 0;
2412 ses->serverOS[1 + (2 * len)] = 0;
2413 if (remaining_words > 0) {
2414 len = UniStrnlen((wchar_t *)bcc_ptr,
2416 kfree(ses->serverNOS);
2417 ses->serverNOS = kzalloc(2 * (len + 1),
2419 if (ses->serverNOS == NULL)
2420 goto sesssetup_nomem;
2421 cifs_strfromUCS_le(ses->serverNOS,
2424 bcc_ptr += 2 * (len + 1);
2425 ses->serverNOS[2 * len] = 0;
2426 ses->serverNOS[1 + (2 * len)] = 0;
2427 if (strncmp(ses->serverNOS,
2428 "NT LAN Manager 4", 16) == 0) {
2429 cFYI(1, ("NT4 server"));
2430 ses->flags |= CIFS_SES_NT4;
2432 remaining_words -= len + 1;
2433 if (remaining_words > 0) {
2434 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2435 /* last string is not always null terminated
2436 (for e.g. for Windows XP & 2000) */
2437 if (ses->serverDomain)
2438 kfree(ses->serverDomain);
2442 if (ses->serverDomain == NULL)
2443 goto sesssetup_nomem;
2444 cifs_strfromUCS_le(ses->serverDomain,
2447 bcc_ptr += 2 * (len + 1);
2448 ses->serverDomain[2*len] = 0;
2449 ses->serverDomain[1+(2*len)] = 0;
2450 } else { /* else no more room so create
2451 dummy domain string */
2452 if (ses->serverDomain)
2453 kfree(ses->serverDomain);
2455 kzalloc(2, GFP_KERNEL);
2457 } else { /* no room so create dummy domain
2460 /* if these kcallocs fail not much we
2461 can do, but better to not fail the
2463 kfree(ses->serverDomain);
2465 kzalloc(2, GFP_KERNEL);
2466 kfree(ses->serverNOS);
2468 kzalloc(2, GFP_KERNEL);
2470 } else { /* ASCII */
2471 len = strnlen(bcc_ptr, 1024);
2472 if (((long) bcc_ptr + len) - (long)
2473 pByteArea(smb_buffer_response)
2474 <= BCC(smb_buffer_response)) {
2475 kfree(ses->serverOS);
2476 ses->serverOS = kzalloc(len + 1,
2478 if (ses->serverOS == NULL)
2479 goto sesssetup_nomem;
2480 strncpy(ses->serverOS, bcc_ptr, len);
2483 /* null terminate the string */
2487 len = strnlen(bcc_ptr, 1024);
2488 kfree(ses->serverNOS);
2489 ses->serverNOS = kzalloc(len + 1,
2491 if (ses->serverNOS == NULL)
2492 goto sesssetup_nomem;
2493 strncpy(ses->serverNOS, bcc_ptr, len);
2498 len = strnlen(bcc_ptr, 1024);
2499 if (ses->serverDomain)
2500 kfree(ses->serverDomain);
2501 ses->serverDomain = kzalloc(len + 1,
2503 if (ses->serverDomain == NULL)
2504 goto sesssetup_nomem;
2505 strncpy(ses->serverDomain, bcc_ptr,
2512 ("Variable field of length %d "
2513 "extends beyond end of smb ",
2518 (" Security Blob Length extends beyond "
2523 (" Invalid Word count %d: ",
2524 smb_buffer_response->WordCount));
2527 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2528 since that could make reconnection harder, and
2529 reconnection might be needed to free memory */
2530 cifs_buf_release(smb_buffer);
2536 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2537 struct cifsSesInfo *ses, int *pNTLMv2_flag,
2538 const struct nls_table *nls_codepage)
2540 struct smb_hdr *smb_buffer;
2541 struct smb_hdr *smb_buffer_response;
2542 SESSION_SETUP_ANDX *pSMB;
2543 SESSION_SETUP_ANDX *pSMBr;
2547 int remaining_words = 0;
2548 int bytes_returned = 0;
2550 int SecurityBlobLength = sizeof (NEGOTIATE_MESSAGE);
2551 PNEGOTIATE_MESSAGE SecurityBlob;
2552 PCHALLENGE_MESSAGE SecurityBlob2;
2553 __u32 negotiate_flags, capabilities;
2556 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2559 domain = ses->domainName;
2560 *pNTLMv2_flag = FALSE;
2561 smb_buffer = cifs_buf_get();
2562 if (smb_buffer == NULL) {
2565 smb_buffer_response = smb_buffer;
2566 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2567 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2569 /* send SMBsessionSetup here */
2570 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2571 NULL /* no tCon exists yet */ , 12 /* wct */ );
2573 smb_buffer->Mid = GetNextMid(ses->server);
2574 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2575 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2577 pSMB->req.AndXCommand = 0xFF;
2578 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2579 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2581 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2582 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2584 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2585 CAP_EXTENDED_SECURITY;
2586 if (ses->capabilities & CAP_UNICODE) {
2587 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2588 capabilities |= CAP_UNICODE;
2590 if (ses->capabilities & CAP_STATUS32) {
2591 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2592 capabilities |= CAP_STATUS32;
2594 if (ses->capabilities & CAP_DFS) {
2595 smb_buffer->Flags2 |= SMBFLG2_DFS;
2596 capabilities |= CAP_DFS;
2598 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2600 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2601 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2602 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2603 SecurityBlob->MessageType = NtLmNegotiate;
2605 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2606 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2607 NTLMSSP_NEGOTIATE_56 |
2608 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2610 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2611 /* if (ntlmv2_support)
2612 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2613 /* setup pointers to domain name and workstation name */
2614 bcc_ptr += SecurityBlobLength;
2616 SecurityBlob->WorkstationName.Buffer = 0;
2617 SecurityBlob->WorkstationName.Length = 0;
2618 SecurityBlob->WorkstationName.MaximumLength = 0;
2620 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2621 along with username on auth request (ie the response to challenge) */
2622 SecurityBlob->DomainName.Buffer = 0;
2623 SecurityBlob->DomainName.Length = 0;
2624 SecurityBlob->DomainName.MaximumLength = 0;
2625 if (ses->capabilities & CAP_UNICODE) {
2626 if ((long) bcc_ptr % 2) {
2632 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2634 bcc_ptr += 2 * bytes_returned;
2636 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2638 bcc_ptr += 2 * bytes_returned;
2639 bcc_ptr += 2; /* null terminate Linux version */
2641 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2643 bcc_ptr += 2 * bytes_returned;
2646 bcc_ptr += 2; /* null terminate network opsys string */
2649 bcc_ptr += 2; /* null domain */
2650 } else { /* ASCII */
2651 strcpy(bcc_ptr, "Linux version ");
2652 bcc_ptr += strlen("Linux version ");
2653 strcpy(bcc_ptr, utsname()->release);
2654 bcc_ptr += strlen(utsname()->release) + 1;
2655 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2656 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2657 bcc_ptr++; /* empty domain field */
2660 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2661 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2662 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2663 smb_buffer->smb_buf_length += count;
2664 pSMB->req.ByteCount = cpu_to_le16(count);
2666 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2667 &bytes_returned, 1);
2669 if (smb_buffer_response->Status.CifsError ==
2670 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2674 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2675 } else if ((smb_buffer_response->WordCount == 3)
2676 || (smb_buffer_response->WordCount == 4)) {
2677 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2678 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2680 if (action & GUEST_LOGIN)
2681 cFYI(1, (" Guest login"));
2682 /* Do we want to set anything in SesInfo struct when guest login? */
2684 bcc_ptr = pByteArea(smb_buffer_response);
2685 /* response can have either 3 or 4 word count - Samba sends 3 */
2687 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2688 if (SecurityBlob2->MessageType != NtLmChallenge) {
2690 ("Unexpected NTLMSSP message type received %d",
2691 SecurityBlob2->MessageType));
2693 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2694 cFYI(1, ("UID = %d", ses->Suid));
2695 if ((pSMBr->resp.hdr.WordCount == 3)
2696 || ((pSMBr->resp.hdr.WordCount == 4)
2698 pSMBr->resp.ByteCount))) {
2700 if (pSMBr->resp.hdr.WordCount == 4) {
2701 bcc_ptr += blob_len;
2702 cFYI(1, ("Security Blob Length %d",
2706 cFYI(1, ("NTLMSSP Challenge rcvd"));
2708 memcpy(ses->server->cryptKey,
2709 SecurityBlob2->Challenge,
2710 CIFS_CRYPTO_KEY_SIZE);
2711 if (SecurityBlob2->NegotiateFlags &
2712 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2713 *pNTLMv2_flag = TRUE;
2715 if ((SecurityBlob2->NegotiateFlags &
2716 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2717 || (sign_CIFS_PDUs > 1))
2718 ses->server->secMode |=
2719 SECMODE_SIGN_REQUIRED;
2720 if ((SecurityBlob2->NegotiateFlags &
2721 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2722 ses->server->secMode |=
2723 SECMODE_SIGN_ENABLED;
2725 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2726 if ((long) (bcc_ptr) % 2) {
2728 (BCC(smb_buffer_response)
2730 /* Must word align unicode strings */
2735 (smb_buffer_response) / 2;
2738 UniStrnlen((wchar_t *) bcc_ptr,
2739 remaining_words - 1);
2740 /* We look for obvious messed up bcc or strings in response so we do not go off
2741 the end since (at least) WIN2K and Windows XP have a major bug in not null
2742 terminating last Unicode string in response */
2744 kfree(ses->serverOS);
2746 kzalloc(2 * (len + 1), GFP_KERNEL);
2747 cifs_strfromUCS_le(ses->serverOS,
2751 bcc_ptr += 2 * (len + 1);
2752 remaining_words -= len + 1;
2753 ses->serverOS[2 * len] = 0;
2754 ses->serverOS[1 + (2 * len)] = 0;
2755 if (remaining_words > 0) {
2756 len = UniStrnlen((wchar_t *)
2760 kfree(ses->serverNOS);
2762 kzalloc(2 * (len + 1),
2764 cifs_strfromUCS_le(ses->
2770 bcc_ptr += 2 * (len + 1);
2771 ses->serverNOS[2 * len] = 0;
2774 remaining_words -= len + 1;
2775 if (remaining_words > 0) {
2776 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2777 /* last string not always null terminated
2778 (for e.g. for Windows XP & 2000) */
2779 kfree(ses->serverDomain);
2791 ses->serverDomain[2*len]
2796 } /* else no more room so create dummy domain string */
2798 kfree(ses->serverDomain);
2803 } else { /* no room so create dummy domain and NOS string */
2804 kfree(ses->serverDomain);
2806 kzalloc(2, GFP_KERNEL);
2807 kfree(ses->serverNOS);
2809 kzalloc(2, GFP_KERNEL);
2811 } else { /* ASCII */
2812 len = strnlen(bcc_ptr, 1024);
2813 if (((long) bcc_ptr + len) - (long)
2814 pByteArea(smb_buffer_response)
2815 <= BCC(smb_buffer_response)) {
2817 kfree(ses->serverOS);
2821 strncpy(ses->serverOS,
2825 bcc_ptr[0] = 0; /* null terminate string */
2828 len = strnlen(bcc_ptr, 1024);
2829 kfree(ses->serverNOS);
2833 strncpy(ses->serverNOS, bcc_ptr, len);
2838 len = strnlen(bcc_ptr, 1024);
2839 kfree(ses->serverDomain);
2843 strncpy(ses->serverDomain,
2850 ("field of length %d "
2851 "extends beyond end of smb",
2855 cERROR(1, ("Security Blob Length extends beyond"
2859 cERROR(1, ("No session structure passed in."));
2863 (" Invalid Word count %d:",
2864 smb_buffer_response->WordCount));
2868 cifs_buf_release(smb_buffer);
2873 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2874 char *ntlm_session_key, int ntlmv2_flag,
2875 const struct nls_table *nls_codepage)
2877 struct smb_hdr *smb_buffer;
2878 struct smb_hdr *smb_buffer_response;
2879 SESSION_SETUP_ANDX *pSMB;
2880 SESSION_SETUP_ANDX *pSMBr;
2885 int remaining_words = 0;
2886 int bytes_returned = 0;
2888 int SecurityBlobLength = sizeof (AUTHENTICATE_MESSAGE);
2889 PAUTHENTICATE_MESSAGE SecurityBlob;
2890 __u32 negotiate_flags, capabilities;
2893 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2896 user = ses->userName;
2897 domain = ses->domainName;
2898 smb_buffer = cifs_buf_get();
2899 if (smb_buffer == NULL) {
2902 smb_buffer_response = smb_buffer;
2903 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2904 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2906 /* send SMBsessionSetup here */
2907 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2908 NULL /* no tCon exists yet */ , 12 /* wct */ );
2910 smb_buffer->Mid = GetNextMid(ses->server);
2911 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2912 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2913 pSMB->req.AndXCommand = 0xFF;
2914 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2915 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2917 pSMB->req.hdr.Uid = ses->Suid;
2919 if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2920 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2922 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2923 CAP_EXTENDED_SECURITY;
2924 if (ses->capabilities & CAP_UNICODE) {
2925 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2926 capabilities |= CAP_UNICODE;
2928 if (ses->capabilities & CAP_STATUS32) {
2929 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2930 capabilities |= CAP_STATUS32;
2932 if (ses->capabilities & CAP_DFS) {
2933 smb_buffer->Flags2 |= SMBFLG2_DFS;
2934 capabilities |= CAP_DFS;
2936 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2938 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2939 SecurityBlob = (PAUTHENTICATE_MESSAGE) bcc_ptr;
2940 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2941 SecurityBlob->MessageType = NtLmAuthenticate;
2942 bcc_ptr += SecurityBlobLength;
2944 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
2945 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
2946 0x80000000 | NTLMSSP_NEGOTIATE_128;
2948 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
2950 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
2952 /* setup pointers to domain name and workstation name */
2954 SecurityBlob->WorkstationName.Buffer = 0;
2955 SecurityBlob->WorkstationName.Length = 0;
2956 SecurityBlob->WorkstationName.MaximumLength = 0;
2957 SecurityBlob->SessionKey.Length = 0;
2958 SecurityBlob->SessionKey.MaximumLength = 0;
2959 SecurityBlob->SessionKey.Buffer = 0;
2961 SecurityBlob->LmChallengeResponse.Length = 0;
2962 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
2963 SecurityBlob->LmChallengeResponse.Buffer = 0;
2965 SecurityBlob->NtChallengeResponse.Length =
2966 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2967 SecurityBlob->NtChallengeResponse.MaximumLength =
2968 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2969 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
2970 SecurityBlob->NtChallengeResponse.Buffer =
2971 cpu_to_le32(SecurityBlobLength);
2972 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
2973 bcc_ptr += CIFS_SESS_KEY_SIZE;
2975 if (ses->capabilities & CAP_UNICODE) {
2976 if (domain == NULL) {
2977 SecurityBlob->DomainName.Buffer = 0;
2978 SecurityBlob->DomainName.Length = 0;
2979 SecurityBlob->DomainName.MaximumLength = 0;
2981 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2984 SecurityBlob->DomainName.MaximumLength =
2986 SecurityBlob->DomainName.Buffer =
2987 cpu_to_le32(SecurityBlobLength);
2989 SecurityBlobLength += ln;
2990 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
2993 SecurityBlob->UserName.Buffer = 0;
2994 SecurityBlob->UserName.Length = 0;
2995 SecurityBlob->UserName.MaximumLength = 0;
2997 __u16 ln = cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
3000 SecurityBlob->UserName.MaximumLength =
3002 SecurityBlob->UserName.Buffer =
3003 cpu_to_le32(SecurityBlobLength);
3005 SecurityBlobLength += ln;
3006 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3009 /* SecurityBlob->WorkstationName.Length =
3010 cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
3011 SecurityBlob->WorkstationName.Length *= 2;
3012 SecurityBlob->WorkstationName.MaximumLength =
3013 cpu_to_le16(SecurityBlob->WorkstationName.Length);
3014 SecurityBlob->WorkstationName.Buffer =
3015 cpu_to_le32(SecurityBlobLength);
3016 bcc_ptr += SecurityBlob->WorkstationName.Length;
3017 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
3018 SecurityBlob->WorkstationName.Length =
3019 cpu_to_le16(SecurityBlob->WorkstationName.Length); */
3021 if ((long) bcc_ptr % 2) {
3026 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
3028 bcc_ptr += 2 * bytes_returned;
3030 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
3032 bcc_ptr += 2 * bytes_returned;
3033 bcc_ptr += 2; /* null term version string */
3035 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
3037 bcc_ptr += 2 * bytes_returned;
3040 bcc_ptr += 2; /* null terminate network opsys string */
3043 bcc_ptr += 2; /* null domain */
3044 } else { /* ASCII */
3045 if (domain == NULL) {
3046 SecurityBlob->DomainName.Buffer = 0;
3047 SecurityBlob->DomainName.Length = 0;
3048 SecurityBlob->DomainName.MaximumLength = 0;
3051 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
3052 strncpy(bcc_ptr, domain, 63);
3053 ln = strnlen(domain, 64);
3054 SecurityBlob->DomainName.MaximumLength =
3056 SecurityBlob->DomainName.Buffer =
3057 cpu_to_le32(SecurityBlobLength);
3059 SecurityBlobLength += ln;
3060 SecurityBlob->DomainName.Length = cpu_to_le16(ln);
3063 SecurityBlob->UserName.Buffer = 0;
3064 SecurityBlob->UserName.Length = 0;
3065 SecurityBlob->UserName.MaximumLength = 0;
3068 strncpy(bcc_ptr, user, 63);
3069 ln = strnlen(user, 64);
3070 SecurityBlob->UserName.MaximumLength = cpu_to_le16(ln);
3071 SecurityBlob->UserName.Buffer =
3072 cpu_to_le32(SecurityBlobLength);
3074 SecurityBlobLength += ln;
3075 SecurityBlob->UserName.Length = cpu_to_le16(ln);
3077 /* BB fill in our workstation name if known BB */
3079 strcpy(bcc_ptr, "Linux version ");
3080 bcc_ptr += strlen("Linux version ");
3081 strcpy(bcc_ptr, utsname()->release);
3082 bcc_ptr += strlen(utsname()->release) + 1;
3083 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
3084 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
3085 bcc_ptr++; /* null domain */
3088 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
3089 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
3090 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
3091 smb_buffer->smb_buf_length += count;
3092 pSMB->req.ByteCount = cpu_to_le16(count);
3094 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
3095 &bytes_returned, 1);
3097 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
3098 } else if ((smb_buffer_response->WordCount == 3)
3099 || (smb_buffer_response->WordCount == 4)) {
3100 __u16 action = le16_to_cpu(pSMBr->resp.Action);
3102 le16_to_cpu(pSMBr->resp.SecurityBlobLength);
3103 if (action & GUEST_LOGIN)
3104 cFYI(1, (" Guest login")); /* BB Should we set anything
3105 in SesInfo struct ? */
3106 /* if (SecurityBlob2->MessageType != NtLm??) {
3107 cFYI("Unexpected message type on auth response is %d"));
3112 ("Check challenge UID %d vs auth response UID %d",
3113 ses->Suid, smb_buffer_response->Uid));
3114 /* UID left in wire format */
3115 ses->Suid = smb_buffer_response->Uid;
3116 bcc_ptr = pByteArea(smb_buffer_response);
3117 /* response can have either 3 or 4 word count - Samba sends 3 */
3118 if ((pSMBr->resp.hdr.WordCount == 3)
3119 || ((pSMBr->resp.hdr.WordCount == 4)
3121 pSMBr->resp.ByteCount))) {
3122 if (pSMBr->resp.hdr.WordCount == 4) {
3126 ("Security Blob Length %d ",
3131 ("NTLMSSP response to Authenticate "));
3133 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3134 if ((long) (bcc_ptr) % 2) {
3136 (BCC(smb_buffer_response)
3138 bcc_ptr++; /* Unicode strings must be word aligned */
3140 remaining_words = BCC(smb_buffer_response) / 2;
3142 len = UniStrnlen((wchar_t *) bcc_ptr,
3143 remaining_words - 1);
3144 /* We look for obvious messed up bcc or strings in response so we do not go off
3145 the end since (at least) WIN2K and Windows XP have a major bug in not null
3146 terminating last Unicode string in response */
3148 kfree(ses->serverOS);
3150 kzalloc(2 * (len + 1), GFP_KERNEL);
3151 cifs_strfromUCS_le(ses->serverOS,
3155 bcc_ptr += 2 * (len + 1);
3156 remaining_words -= len + 1;
3157 ses->serverOS[2 * len] = 0;
3158 ses->serverOS[1 + (2 * len)] = 0;
3159 if (remaining_words > 0) {
3160 len = UniStrnlen((wchar_t *)
3164 kfree(ses->serverNOS);
3166 kzalloc(2 * (len + 1),
3168 cifs_strfromUCS_le(ses->
3174 bcc_ptr += 2 * (len + 1);
3175 ses->serverNOS[2 * len] = 0;
3176 ses->serverNOS[1+(2*len)] = 0;
3177 remaining_words -= len + 1;
3178 if (remaining_words > 0) {
3179 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3180 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3181 if (ses->serverDomain)
3182 kfree(ses->serverDomain);
3207 } /* else no more room so create dummy domain string */
3209 if (ses->serverDomain)
3210 kfree(ses->serverDomain);
3211 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3213 } else { /* no room so create dummy domain and NOS string */
3214 if (ses->serverDomain)
3215 kfree(ses->serverDomain);
3216 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3217 kfree(ses->serverNOS);
3218 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3220 } else { /* ASCII */
3221 len = strnlen(bcc_ptr, 1024);
3222 if (((long) bcc_ptr + len) -
3223 (long) pByteArea(smb_buffer_response)
3224 <= BCC(smb_buffer_response)) {
3226 kfree(ses->serverOS);
3227 ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
3228 strncpy(ses->serverOS,bcc_ptr, len);
3231 bcc_ptr[0] = 0; /* null terminate the string */
3234 len = strnlen(bcc_ptr, 1024);
3235 kfree(ses->serverNOS);
3236 ses->serverNOS = kzalloc(len+1,
3238 strncpy(ses->serverNOS,
3244 len = strnlen(bcc_ptr, 1024);
3245 if (ses->serverDomain)
3246 kfree(ses->serverDomain);
3250 strncpy(ses->serverDomain,
3257 ("field of length %d "
3258 "extends beyond end of smb ",
3263 (" Security Blob extends beyond end "
3267 cERROR(1, ("No session structure passed in."));
3271 (" Invalid Word count %d: ",
3272 smb_buffer_response->WordCount));
3276 cifs_buf_release(smb_buffer);
3282 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3283 const char *tree, struct cifsTconInfo *tcon,
3284 const struct nls_table *nls_codepage)
3286 struct smb_hdr *smb_buffer;
3287 struct smb_hdr *smb_buffer_response;
3290 unsigned char *bcc_ptr;
3298 smb_buffer = cifs_buf_get();
3299 if (smb_buffer == NULL) {
3302 smb_buffer_response = smb_buffer;
3304 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3305 NULL /*no tid */ , 4 /*wct */ );
3307 smb_buffer->Mid = GetNextMid(ses->server);
3308 smb_buffer->Uid = ses->Suid;
3309 pSMB = (TCONX_REQ *) smb_buffer;
3310 pSMBr = (TCONX_RSP *) smb_buffer_response;
3312 pSMB->AndXCommand = 0xFF;
3313 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3314 bcc_ptr = &pSMB->Password[0];
3315 if ((ses->server->secMode) & SECMODE_USER) {
3316 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3317 *bcc_ptr = 0; /* password is null byte */
3318 bcc_ptr++; /* skip password */
3319 /* already aligned so no need to do it below */
3321 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3322 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3323 specified as required (when that support is added to
3324 the vfs in the future) as only NTLM or the much
3325 weaker LANMAN (which we do not send by default) is accepted
3326 by Samba (not sure whether other servers allow
3327 NTLMv2 password here) */
3328 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3329 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
3330 (ses->server->secType == LANMAN))
3331 calc_lanman_hash(ses, bcc_ptr);
3333 #endif /* CIFS_WEAK_PW_HASH */
3334 SMBNTencrypt(ses->password,
3335 ses->server->cryptKey,
3338 bcc_ptr += CIFS_SESS_KEY_SIZE;
3339 if (ses->capabilities & CAP_UNICODE) {
3340 /* must align unicode strings */
3341 *bcc_ptr = 0; /* null byte password */
3346 if (ses->server->secMode &
3347 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3348 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3350 if (ses->capabilities & CAP_STATUS32) {
3351 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3353 if (ses->capabilities & CAP_DFS) {
3354 smb_buffer->Flags2 |= SMBFLG2_DFS;
3356 if (ses->capabilities & CAP_UNICODE) {
3357 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3359 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3360 6 /* max utf8 char length in bytes */ *
3361 (/* server len*/ + 256 /* share len */), nls_codepage);
3362 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3363 bcc_ptr += 2; /* skip trailing null */
3364 } else { /* ASCII */
3365 strcpy(bcc_ptr, tree);
3366 bcc_ptr += strlen(tree) + 1;
3368 strcpy(bcc_ptr, "?????");
3369 bcc_ptr += strlen("?????");
3371 count = bcc_ptr - &pSMB->Password[0];
3372 pSMB->hdr.smb_buf_length += count;
3373 pSMB->ByteCount = cpu_to_le16(count);
3375 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length, 0);
3377 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3378 /* above now done in SendReceive */
3379 if ((rc == 0) && (tcon != NULL)) {
3380 tcon->tidStatus = CifsGood;
3381 tcon->tid = smb_buffer_response->Tid;
3382 bcc_ptr = pByteArea(smb_buffer_response);
3383 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3384 /* skip service field (NB: this field is always ASCII) */
3386 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3387 (bcc_ptr[2] == 'C')) {
3388 cFYI(1, ("IPC connection"));
3391 } else if (length == 2) {
3392 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3393 /* the most common case */
3394 cFYI(1, ("disk share connection"));
3397 bcc_ptr += length + 1;
3398 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3399 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3400 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3401 if ((bcc_ptr + (2 * length)) -
3402 pByteArea(smb_buffer_response) <=
3403 BCC(smb_buffer_response)) {
3404 kfree(tcon->nativeFileSystem);
3405 tcon->nativeFileSystem =
3406 kzalloc(length + 2, GFP_KERNEL);
3407 if (tcon->nativeFileSystem)
3409 tcon->nativeFileSystem,
3411 length, nls_codepage);
3412 bcc_ptr += 2 * length;
3413 bcc_ptr[0] = 0; /* null terminate the string */
3417 /* else do not bother copying these information fields*/
3419 length = strnlen(bcc_ptr, 1024);
3420 if ((bcc_ptr + length) -
3421 pByteArea(smb_buffer_response) <=
3422 BCC(smb_buffer_response)) {
3423 kfree(tcon->nativeFileSystem);
3424 tcon->nativeFileSystem =
3425 kzalloc(length + 1, GFP_KERNEL);
3426 if (tcon->nativeFileSystem)
3427 strncpy(tcon->nativeFileSystem, bcc_ptr,
3430 /* else do not bother copying these information fields*/
3432 if ((smb_buffer_response->WordCount == 3) ||
3433 (smb_buffer_response->WordCount == 7))
3434 /* field is in same location */
3435 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3438 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3439 } else if ((rc == 0) && tcon == NULL) {
3440 /* all we need to save for IPC$ connection */
3441 ses->ipc_tid = smb_buffer_response->Tid;
3444 cifs_buf_release(smb_buffer);
3449 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3453 struct cifsSesInfo *ses = NULL;
3454 struct task_struct *cifsd_task;
3459 if (cifs_sb->tcon) {
3460 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3461 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3466 tconInfoFree(cifs_sb->tcon);
3467 if ((ses) && (ses->server)) {
3468 /* save off task so we do not refer to ses later */
3469 cifsd_task = ses->server->tsk;
3470 cFYI(1, ("About to do SMBLogoff "));
3471 rc = CIFSSMBLogoff(xid, ses);
3475 } else if (rc == -ESHUTDOWN) {
3476 cFYI(1, ("Waking up socket by sending signal"));
3478 force_sig(SIGKILL, cifsd_task);
3479 kthread_stop(cifsd_task);
3482 } /* else - we have an smb session
3483 left on this socket do not kill cifsd */
3485 cFYI(1, ("No session or bad tcon"));
3488 cifs_sb->tcon = NULL;
3489 tmp = cifs_sb->prepath;
3490 cifs_sb->prepathlen = 0;
3491 cifs_sb->prepath = NULL;
3494 schedule_timeout_interruptible(msecs_to_jiffies(500));
3499 return rc; /* BB check if we should always return zero here */
3502 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3503 struct nls_table *nls_info)
3506 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3507 int ntlmv2_flag = FALSE;
3510 /* what if server changes its buffer size after dropping the session? */
3511 if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3512 rc = CIFSSMBNegotiate(xid, pSesInfo);
3513 if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
3514 rc = CIFSSMBNegotiate(xid, pSesInfo);
3519 spin_lock(&GlobalMid_Lock);
3520 if (pSesInfo->server->tcpStatus != CifsExiting)
3521 pSesInfo->server->tcpStatus = CifsGood;
3524 spin_unlock(&GlobalMid_Lock);
3530 pSesInfo->flags = 0;
3531 pSesInfo->capabilities = pSesInfo->server->capabilities;
3532 if (linuxExtEnabled == 0)
3533 pSesInfo->capabilities &= (~CAP_UNIX);
3534 /* pSesInfo->sequence_number = 0;*/
3536 ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3537 pSesInfo->server->secMode,
3538 pSesInfo->server->capabilities,
3539 pSesInfo->server->timeAdj));
3540 if (experimEnabled < 2)
3541 rc = CIFS_SessSetup(xid, pSesInfo,
3542 first_time, nls_info);
3543 else if (extended_security
3544 && (pSesInfo->capabilities
3545 & CAP_EXTENDED_SECURITY)
3546 && (pSesInfo->server->secType == NTLMSSP)) {
3548 } else if (extended_security
3549 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3550 && (pSesInfo->server->secType == RawNTLMSSP)) {
3551 cFYI(1, ("NTLMSSP sesssetup"));
3552 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3559 cFYI(1, ("more secure NTLM ver2 hash"));
3560 if (CalcNTLMv2_partial_mac_key(pSesInfo,
3565 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3567 CalcNTLMv2_response(pSesInfo,
3570 cifs_calculate_ntlmv2_mac_key(
3571 pSesInfo->server->mac_signing_key,
3572 response, ntlm_session_key,*/
3574 /* BB Put dummy sig in SessSetup PDU? */
3581 SMBNTencrypt(pSesInfo->password,
3582 pSesInfo->server->cryptKey,
3586 cifs_calculate_mac_key(
3587 &pSesInfo->server->mac_signing_key,
3589 pSesInfo->password);
3591 /* for better security the weaker lanman hash not sent
3592 in AuthSessSetup so we no longer calculate it */
3594 rc = CIFSNTLMSSPAuthSessSetup(xid,
3600 } else { /* old style NTLM 0.12 session setup */
3601 SMBNTencrypt(pSesInfo->password,
3602 pSesInfo->server->cryptKey,
3606 cifs_calculate_mac_key(
3607 &pSesInfo->server->mac_signing_key,
3608 ntlm_session_key, pSesInfo->password);
3610 rc = CIFSSessSetup(xid, pSesInfo,
3611 ntlm_session_key, nls_info);
3614 cERROR(1, ("Send error in SessSetup = %d", rc));
3616 cFYI(1, ("CIFS Session Established successfully"));
3617 pSesInfo->status = CifsGood;