?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Freezer: make kernel threads nonfreezable by default
[linux-2.6/kmemtrace.git] / fs / cifs / connect.c
blob0a1b8bd1dfcbcf113274107b6ea3bb491bd03cd3
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2006
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
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.
11 *
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.
16 *
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
20 */
21 #include <linux/fs.h>
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>
38 #include "cifspdu.h"
39 #include "cifsglob.h"
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
44 #include "ntlmssp.h"
45 #include "nterr.h"
46 #include "rfc1002pdu.h"
47 #include "cn_cifs.h"
48
49 #define CIFS_PORT 445
50 #define RFC1001_PORT 139
51
52 static DECLARE_COMPLETION(cifsd_complete);
53
54 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
55 unsigned char *p24);
56
57 extern mempool_t *cifs_req_poolp;
58
59 struct smb_vol {
60 char *username;
61 char *password;
62 char *domainname;
63 char *UNC;
64 char *UNCip;
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 */
69 uid_t linux_uid;
70 gid_t linux_gid;
71 mode_t file_mode;
72 mode_t dir_mode;
73 unsigned secFlg;
74 unsigned rw:1;
75 unsigned retry:1;
76 unsigned intr:1;
77 unsigned setuids:1;
78 unsigned override_uid:1;
79 unsigned override_gid:1;
80 unsigned noperm:1;
81 unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
82 unsigned cifs_acl:1;
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 */
85 unsigned direct_io:1;
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 sfu_emul:1;
89 unsigned nullauth:1; /* attempt to authenticate with null user */
90 unsigned nocase; /* request case insensitive filenames */
91 unsigned nobrl; /* disable sending byte range locks to srv */
92 unsigned int rsize;
93 unsigned int wsize;
94 unsigned int sockopt;
95 unsigned short int port;
96 char * prepath;
97 };
98
99 static int ipv4_connect(struct sockaddr_in *psin_server,
100 struct socket **csocket,
101 char * netb_name,
102 char * server_netb_name);
103 static int ipv6_connect(struct sockaddr_in6 *psin_server,
104 struct socket **csocket);
105
106
107 /*
108 * cifs tcp session reconnection
109 *
110 * mark tcp session as reconnecting so temporarily locked
111 * mark all smb sessions as reconnecting for tcp session
112 * reconnect tcp session
113 * wake up waiters on reconnection? - (not needed currently)
114 */
115
116 static int
117 cifs_reconnect(struct TCP_Server_Info *server)
118 {
119 int rc = 0;
120 struct list_head *tmp;
121 struct cifsSesInfo *ses;
122 struct cifsTconInfo *tcon;
123 struct mid_q_entry * mid_entry;
124
125 spin_lock(&GlobalMid_Lock);
126 if( kthread_should_stop() ) {
127 /* the demux thread will exit normally
128 next time through the loop */
129 spin_unlock(&GlobalMid_Lock);
130 return rc;
131 } else
132 server->tcpStatus = CifsNeedReconnect;
133 spin_unlock(&GlobalMid_Lock);
134 server->maxBuf = 0;
135
136 cFYI(1, ("Reconnecting tcp session"));
137
138 /* before reconnecting the tcp session, mark the smb session (uid)
139 and the tid bad so they are not used until reconnected */
140 read_lock(&GlobalSMBSeslock);
141 list_for_each(tmp, &GlobalSMBSessionList) {
142 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
143 if (ses->server) {
144 if (ses->server == server) {
145 ses->status = CifsNeedReconnect;
146 ses->ipc_tid = 0;
147 }
148 }
149 /* else tcp and smb sessions need reconnection */
150 }
151 list_for_each(tmp, &GlobalTreeConnectionList) {
152 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
153 if((tcon) && (tcon->ses) && (tcon->ses->server == server)) {
154 tcon->tidStatus = CifsNeedReconnect;
155 }
156 }
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", server->ssocket->state,
165 server->ssocket->flags));
166 sock_release(server->ssocket);
167 server->ssocket = NULL;
168 }
169
170 spin_lock(&GlobalMid_Lock);
171 list_for_each(tmp, &server->pending_mid_q) {
172 mid_entry = list_entry(tmp, struct
173 mid_q_entry,
174 qhead);
175 if(mid_entry) {
176 if(mid_entry->midState == MID_REQUEST_SUBMITTED) {
177 /* Mark other intransit requests as needing
178 retry so we do not immediately mark the
179 session bad again (ie after we reconnect
180 below) as they timeout too */
181 mid_entry->midState = MID_RETRY_NEEDED;
182 }
183 }
184 }
185 spin_unlock(&GlobalMid_Lock);
186 up(&server->tcpSem);
187
188 while ( (!kthread_should_stop()) && (server->tcpStatus != CifsGood))
189 {
190 try_to_freeze();
191 if(server->protocolType == IPV6) {
192 rc = ipv6_connect(&server->addr.sockAddr6,&server->ssocket);
193 } else {
194 rc = ipv4_connect(&server->addr.sockAddr,
195 &server->ssocket,
196 server->workstation_RFC1001_name,
197 server->server_RFC1001_name);
198 }
199 if(rc) {
200 cFYI(1,("reconnect error %d",rc));
201 msleep(3000);
202 } else {
203 atomic_inc(&tcpSesReconnectCount);
204 spin_lock(&GlobalMid_Lock);
205 if( !kthread_should_stop() )
206 server->tcpStatus = CifsGood;
207 server->sequence_number = 0;
208 spin_unlock(&GlobalMid_Lock);
209 /* atomic_set(&server->inFlight,0);*/
210 wake_up(&server->response_q);
211 }
212 }
213 return rc;
214 }
215
216 /*
217 return codes:
218 0 not a transact2, or all data present
219 >0 transact2 with that much data missing
220 -EINVAL = invalid transact2
221
222 */
223 static int check2ndT2(struct smb_hdr * pSMB, unsigned int maxBufSize)
224 {
225 struct smb_t2_rsp * pSMBt;
226 int total_data_size;
227 int data_in_this_rsp;
228 int remaining;
229
230 if(pSMB->Command != SMB_COM_TRANSACTION2)
231 return 0;
232
233 /* check for plausible wct, bcc and t2 data and parm sizes */
234 /* check for parm and data offset going beyond end of smb */
235 if(pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
236 cFYI(1,("invalid transact2 word count"));
237 return -EINVAL;
238 }
239
240 pSMBt = (struct smb_t2_rsp *)pSMB;
241
242 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
243 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
244
245 remaining = total_data_size - data_in_this_rsp;
246
247 if(remaining == 0)
248 return 0;
249 else if(remaining < 0) {
250 cFYI(1,("total data %d smaller than data in frame %d",
251 total_data_size, data_in_this_rsp));
252 return -EINVAL;
253 } else {
254 cFYI(1,("missing %d bytes from transact2, check next response",
255 remaining));
256 if(total_data_size > maxBufSize) {
257 cERROR(1,("TotalDataSize %d is over maximum buffer %d",
258 total_data_size,maxBufSize));
259 return -EINVAL;
260 }
261 return remaining;
262 }
263 }
264
265 static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
266 {
267 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
268 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
269 int total_data_size;
270 int total_in_buf;
271 int remaining;
272 int total_in_buf2;
273 char * data_area_of_target;
274 char * data_area_of_buf2;
275 __u16 byte_count;
276
277 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
278
279 if(total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
280 cFYI(1,("total data sizes of primary and secondary t2 differ"));
281 }
282
283 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
284
285 remaining = total_data_size - total_in_buf;
286
287 if(remaining < 0)
288 return -EINVAL;
289
290 if(remaining == 0) /* nothing to do, ignore */
291 return 0;
292
293 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
294 if(remaining < total_in_buf2) {
295 cFYI(1,("transact2 2nd response contains too much data"));
296 }
297
298 /* find end of first SMB data area */
299 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
300 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
301 /* validate target area */
302
303 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
304 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
305
306 data_area_of_target += total_in_buf;
307
308 /* copy second buffer into end of first buffer */
309 memcpy(data_area_of_target,data_area_of_buf2,total_in_buf2);
310 total_in_buf += total_in_buf2;
311 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
312 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
313 byte_count += total_in_buf2;
314 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
315
316 byte_count = pTargetSMB->smb_buf_length;
317 byte_count += total_in_buf2;
318
319 /* BB also add check that we are not beyond maximum buffer size */
320
321 pTargetSMB->smb_buf_length = byte_count;
322
323 if(remaining == total_in_buf2) {
324 cFYI(1,("found the last secondary response"));
325 return 0; /* we are done */
326 } else /* more responses to go */
327 return 1;
328
329 }
330
331 static int
332 cifs_demultiplex_thread(struct TCP_Server_Info *server)
333 {
334 int length;
335 unsigned int pdu_length, total_read;
336 struct smb_hdr *smb_buffer = NULL;
337 struct smb_hdr *bigbuf = NULL;
338 struct smb_hdr *smallbuf = NULL;
339 struct msghdr smb_msg;
340 struct kvec iov;
341 struct socket *csocket = server->ssocket;
342 struct list_head *tmp;
343 struct cifsSesInfo *ses;
344 struct task_struct *task_to_wake = NULL;
345 struct mid_q_entry *mid_entry;
346 char temp;
347 int isLargeBuf = FALSE;
348 int isMultiRsp;
349 int reconnect;
350
351 allow_signal(SIGKILL);
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);
360 if(length > 1) {
361 mempool_resize(cifs_req_poolp,
362 length + cifs_min_rcv,
363 GFP_KERNEL);
364 }
365
366 set_freezable();
367 while (!kthread_should_stop()) {
368 if (try_to_freeze())
369 continue;
370 if (bigbuf == NULL) {
371 bigbuf = cifs_buf_get();
372 if (!bigbuf) {
373 cERROR(1, ("No memory for large SMB response"));
374 msleep(3000);
375 /* retry will check if exiting */
376 continue;
377 }
378 } else if (isLargeBuf) {
379 /* we are reusing a dirty large buf, clear its start */
380 memset(bigbuf, 0, sizeof (struct smb_hdr));
381 }
382
383 if (smallbuf == NULL) {
384 smallbuf = cifs_small_buf_get();
385 if (!smallbuf) {
386 cERROR(1, ("No memory for SMB response"));
387 msleep(1000);
388 /* retry will check if exiting */
389 continue;
390 }
391 /* beginning of smb buffer is cleared in our buf_get */
392 } else /* if existing small buf clear beginning */
393 memset(smallbuf, 0, sizeof (struct smb_hdr));
394
395 isLargeBuf = FALSE;
396 isMultiRsp = FALSE;
397 smb_buffer = smallbuf;
398 iov.iov_base = smb_buffer;
399 iov.iov_len = 4;
400 smb_msg.msg_control = NULL;
401 smb_msg.msg_controllen = 0;
402 length =
403 kernel_recvmsg(csocket, &smb_msg,
404 &iov, 1, 4, 0 /* BB see socket.h flags */);
405
406 if ( kthread_should_stop() ) {
407 break;
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;
413 continue;
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 */
418 continue;
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 */
426 break;
427 }
428 if (!try_to_freeze() && (length == -EINTR)) {
429 cFYI(1,("cifsd thread killed"));
430 break;
431 }
432 cFYI(1,("Reconnect after unexpected peek error %d",
433 length));
434 cifs_reconnect(server);
435 csocket = server->ssocket;
436 wake_up(&server->response_q);
437 continue;
438 } else if (length < 4) {
439 cFYI(1,
440 ("Frame under four bytes received (%d bytes long)",
441 length));
442 cifs_reconnect(server);
443 csocket = server->ssocket;
444 wake_up(&server->response_q);
445 continue;
446 }
447
448 /* The right amount was read from socket - 4 bytes */
449 /* so we can now interpret the length field */
450
451 /* the first byte big endian of the length field,
452 is actually not part of the length but the type
453 with the most common, zero, as regular data */
454 temp = *((char *) smb_buffer);
455
456 /* Note that FC 1001 length is big endian on the wire,
457 but we convert it here so it is always manipulated
458 as host byte order */
459 pdu_length = ntohl(smb_buffer->smb_buf_length);
460 smb_buffer->smb_buf_length = pdu_length;
461
462 cFYI(1,("rfc1002 length 0x%x)", pdu_length+4));
463
464 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
465 continue;
466 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
467 cFYI(1,("Good RFC 1002 session rsp"));
468 continue;
469 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
470 /* we get this from Windows 98 instead of
471 an error on SMB negprot response */
472 cFYI(1,("Negative RFC1002 Session Response Error 0x%x)",
473 pdu_length));
474 if(server->tcpStatus == CifsNew) {
475 /* if nack on negprot (rather than
476 ret of smb negprot error) reconnecting
477 not going to help, ret error to mount */
478 break;
479 } else {
480 /* give server a second to
481 clean up before reconnect attempt */
482 msleep(1000);
483 /* always try 445 first on reconnect
484 since we get NACK on some if we ever
485 connected to port 139 (the NACK is
486 since we do not begin with RFC1001
487 session initialize frame) */
488 server->addr.sockAddr.sin_port =
489 htons(CIFS_PORT);
490 cifs_reconnect(server);
491 csocket = server->ssocket;
492 wake_up(&server->response_q);
493 continue;
494 }
495 } else if (temp != (char) 0) {
496 cERROR(1,("Unknown RFC 1002 frame"));
497 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
498 length);
499 cifs_reconnect(server);
500 csocket = server->ssocket;
501 continue;
502 }
503
504 /* else we have an SMB response */
505 if((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
506 (pdu_length < sizeof (struct smb_hdr) - 1 - 4)) {
507 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
508 length, pdu_length+4));
509 cifs_reconnect(server);
510 csocket = server->ssocket;
511 wake_up(&server->response_q);
512 continue;
513 }
514
515 /* else length ok */
516 reconnect = 0;
517
518 if(pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
519 isLargeBuf = TRUE;
520 memcpy(bigbuf, smallbuf, 4);
521 smb_buffer = bigbuf;
522 }
523 length = 0;
524 iov.iov_base = 4 + (char *)smb_buffer;
525 iov.iov_len = pdu_length;
526 for (total_read = 0; total_read < pdu_length;
527 total_read += length) {
528 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
529 pdu_length - total_read, 0);
530 if( kthread_should_stop() ||
531 (length == -EINTR)) {
532 /* then will exit */
533 reconnect = 2;
534 break;
535 } else if (server->tcpStatus == CifsNeedReconnect) {
536 cifs_reconnect(server);
537 csocket = server->ssocket;
538 /* Reconnect wakes up rspns q */
539 /* Now we will reread sock */
540 reconnect = 1;
541 break;
542 } else if ((length == -ERESTARTSYS) ||
543 (length == -EAGAIN)) {
544 msleep(1); /* minimum sleep to prevent looping,
545 allowing socket to clear and app
546 threads to set tcpStatus
547 CifsNeedReconnect if server hung*/
548 continue;
549 } else if (length <= 0) {
550 cERROR(1,("Received no data, expecting %d",
551 pdu_length - total_read));
552 cifs_reconnect(server);
553 csocket = server->ssocket;
554 reconnect = 1;
555 break;
556 }
557 }
558 if(reconnect == 2)
559 break;
560 else if(reconnect == 1)
561 continue;
562
563 length += 4; /* account for rfc1002 hdr */
564
565
566 dump_smb(smb_buffer, length);
567 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
568 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
569 continue;
570 }
571
572
573 task_to_wake = NULL;
574 spin_lock(&GlobalMid_Lock);
575 list_for_each(tmp, &server->pending_mid_q) {
576 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
577
578 if ((mid_entry->mid == smb_buffer->Mid) &&
579 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
580 (mid_entry->command == smb_buffer->Command)) {
581 if(check2ndT2(smb_buffer,server->maxBuf) > 0) {
582 /* We have a multipart transact2 resp */
583 isMultiRsp = TRUE;
584 if(mid_entry->resp_buf) {
585 /* merge response - fix up 1st*/
586 if(coalesce_t2(smb_buffer,
587 mid_entry->resp_buf)) {
588 mid_entry->multiRsp = 1;
589 break;
590 } else {
591 /* all parts received */
592 mid_entry->multiEnd = 1;
593 goto multi_t2_fnd;
594 }
595 } else {
596 if(!isLargeBuf) {
597 cERROR(1,("1st trans2 resp needs bigbuf"));
598 /* BB maybe we can fix this up, switch
599 to already allocated large buffer? */
600 } else {
601 /* Have first buffer */
602 mid_entry->resp_buf =
603 smb_buffer;
604 mid_entry->largeBuf = 1;
605 bigbuf = NULL;
606 }
607 }
608 break;
609 }
610 mid_entry->resp_buf = smb_buffer;
611 if(isLargeBuf)
612 mid_entry->largeBuf = 1;
613 else
614 mid_entry->largeBuf = 0;
615 multi_t2_fnd:
616 task_to_wake = mid_entry->tsk;
617 mid_entry->midState = MID_RESPONSE_RECEIVED;
618 #ifdef CONFIG_CIFS_STATS2
619 mid_entry->when_received = jiffies;
620 #endif
621 /* so we do not time out requests to server
622 which is still responding (since server could
623 be busy but not dead) */
624 server->lstrp = jiffies;
625 break;
626 }
627 }
628 spin_unlock(&GlobalMid_Lock);
629 if (task_to_wake) {
630 /* Was previous buf put in mpx struct for multi-rsp? */
631 if(!isMultiRsp) {
632 /* smb buffer will be freed by user thread */
633 if(isLargeBuf) {
634 bigbuf = NULL;
635 } else
636 smallbuf = NULL;
637 }
638 wake_up_process(task_to_wake);
639 } else if ((is_valid_oplock_break(smb_buffer, server) == FALSE)
640 && (isMultiRsp == FALSE)) {
641 cERROR(1, ("No task to wake, unknown frame rcvd! NumMids %d", midCount.counter));
642 cifs_dump_mem("Received Data is: ",(char *)smb_buffer,
643 sizeof(struct smb_hdr));
644 #ifdef CONFIG_CIFS_DEBUG2
645 cifs_dump_detail(smb_buffer);
646 cifs_dump_mids(server);
647 #endif /* CIFS_DEBUG2 */
648
649 }
650 } /* end while !EXITING */
651
652 spin_lock(&GlobalMid_Lock);
653 server->tcpStatus = CifsExiting;
654 server->tsk = NULL;
655 /* check if we have blocked requests that need to free */
656 /* Note that cifs_max_pending is normally 50, but
657 can be set at module install time to as little as two */
658 if(atomic_read(&server->inFlight) >= cifs_max_pending)
659 atomic_set(&server->inFlight, cifs_max_pending - 1);
660 /* We do not want to set the max_pending too low or we
661 could end up with the counter going negative */
662 spin_unlock(&GlobalMid_Lock);
663 /* Although there should not be any requests blocked on
664 this queue it can not hurt to be paranoid and try to wake up requests
665 that may haven been blocked when more than 50 at time were on the wire
666 to the same server - they now will see the session is in exit state
667 and get out of SendReceive. */
668 wake_up_all(&server->request_q);
669 /* give those requests time to exit */
670 msleep(125);
671
672 if(server->ssocket) {
673 sock_release(csocket);
674 server->ssocket = NULL;
675 }
676 /* buffer usuallly freed in free_mid - need to free it here on exit */
677 if (bigbuf != NULL)
678 cifs_buf_release(bigbuf);
679 if (smallbuf != NULL)
680 cifs_small_buf_release(smallbuf);
681
682 read_lock(&GlobalSMBSeslock);
683 if (list_empty(&server->pending_mid_q)) {
684 /* loop through server session structures attached to this and
685 mark them dead */
686 list_for_each(tmp, &GlobalSMBSessionList) {
687 ses =
688 list_entry(tmp, struct cifsSesInfo,
689 cifsSessionList);
690 if (ses->server == server) {
691 ses->status = CifsExiting;
692 ses->server = NULL;
693 }
694 }
695 read_unlock(&GlobalSMBSeslock);
696 } else {
697 /* although we can not zero the server struct pointer yet,
698 since there are active requests which may depnd on them,
699 mark the corresponding SMB sessions as exiting too */
700 list_for_each(tmp, &GlobalSMBSessionList) {
701 ses = list_entry(tmp, struct cifsSesInfo,
702 cifsSessionList);
703 if (ses->server == server) {
704 ses->status = CifsExiting;
705 }
706 }
707
708 spin_lock(&GlobalMid_Lock);
709 list_for_each(tmp, &server->pending_mid_q) {
710 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
711 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
712 cFYI(1,
713 ("Clearing Mid 0x%x - waking up ",mid_entry->mid));
714 task_to_wake = mid_entry->tsk;
715 if(task_to_wake) {
716 wake_up_process(task_to_wake);
717 }
718 }
719 }
720 spin_unlock(&GlobalMid_Lock);
721 read_unlock(&GlobalSMBSeslock);
722 /* 1/8th of sec is more than enough time for them to exit */
723 msleep(125);
724 }
725
726 if (!list_empty(&server->pending_mid_q)) {
727 /* mpx threads have not exited yet give them
728 at least the smb send timeout time for long ops */
729 /* due to delays on oplock break requests, we need
730 to wait at least 45 seconds before giving up
731 on a request getting a response and going ahead
732 and killing cifsd */
733 cFYI(1, ("Wait for exit from demultiplex thread"));
734 msleep(46000);
735 /* if threads still have not exited they are probably never
736 coming home not much else we can do but free the memory */
737 }
738
739 write_lock(&GlobalSMBSeslock);
740 atomic_dec(&tcpSesAllocCount);
741 length = tcpSesAllocCount.counter;
742
743 /* last chance to mark ses pointers invalid
744 if there are any pointing to this (e.g
745 if a crazy root user tried to kill cifsd
746 kernel thread explicitly this might happen) */
747 list_for_each(tmp, &GlobalSMBSessionList) {
748 ses = list_entry(tmp, struct cifsSesInfo,
749 cifsSessionList);
750 if (ses->server == server) {
751 ses->server = NULL;
752 }
753 }
754 write_unlock(&GlobalSMBSeslock);
755
756 kfree(server);
757 if(length > 0) {
758 mempool_resize(cifs_req_poolp,
759 length + cifs_min_rcv,
760 GFP_KERNEL);
761 }
762
763 return 0;
764 }
765
766 static int
767 cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
768 {
769 char *value;
770 char *data;
771 unsigned int temp_len, i, j;
772 char separator[2];
773
774 separator[0] = ',';
775 separator[1] = 0;
776
777 if (Local_System_Name[0] != 0)
778 memcpy(vol->source_rfc1001_name, Local_System_Name,15);
779 else {
780 char *nodename = utsname()->nodename;
781 int n = strnlen(nodename,15);
782 memset(vol->source_rfc1001_name,0x20,15);
783 for(i=0 ; i < n ; i++) {
784 /* does not have to be perfect mapping since field is
785 informational, only used for servers that do not support
786 port 445 and it can be overridden at mount time */
787 vol->source_rfc1001_name[i] = toupper(nodename[i]);
788 }
789 }
790 vol->source_rfc1001_name[15] = 0;
791 /* null target name indicates to use *SMBSERVR default called name
792 if we end up sending RFC1001 session initialize */
793 vol->target_rfc1001_name[0] = 0;
794 vol->linux_uid = current->uid; /* current->euid instead? */
795 vol->linux_gid = current->gid;
796 vol->dir_mode = S_IRWXUGO;
797 /* 2767 perms indicate mandatory locking support */
798 vol->file_mode = S_IALLUGO & ~(S_ISUID | S_IXGRP);
799
800 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
801 vol->rw = TRUE;
802 /* default is always to request posix paths. */
803 vol->posix_paths = 1;
804
805 if (!options)
806 return 1;
807
808 if(strncmp(options,"sep=",4) == 0) {
809 if(options[4] != 0) {
810 separator[0] = options[4];
811 options += 5;
812 } else {
813 cFYI(1,("Null separator not allowed"));
814 }
815 }
816
817 while ((data = strsep(&options, separator)) != NULL) {
818 if (!*data)
819 continue;
820 if ((value = strchr(data, '=')) != NULL)
821 *value++ = '\0';
822
823 if (strnicmp(data, "user_xattr",10) == 0) {/*parse before user*/
824 vol->no_xattr = 0;
825 } else if (strnicmp(data, "nouser_xattr",12) == 0) {
826 vol->no_xattr = 1;
827 } else if (strnicmp(data, "user", 4) == 0) {
828 if (!value) {
829 printk(KERN_WARNING
830 "CIFS: invalid or missing username\n");
831 return 1; /* needs_arg; */
832 } else if(!*value) {
833 /* null user, ie anonymous, authentication */
834 vol->nullauth = 1;
835 }
836 if (strnlen(value, 200) < 200) {
837 vol->username = value;
838 } else {
839 printk(KERN_WARNING "CIFS: username too long\n");
840 return 1;
841 }
842 } else if (strnicmp(data, "pass", 4) == 0) {
843 if (!value) {
844 vol->password = NULL;
845 continue;
846 } else if(value[0] == 0) {
847 /* check if string begins with double comma
848 since that would mean the password really
849 does start with a comma, and would not
850 indicate an empty string */
851 if(value[1] != separator[0]) {
852 vol->password = NULL;
853 continue;
854 }
855 }
856 temp_len = strlen(value);
857 /* removed password length check, NTLM passwords
858 can be arbitrarily long */
859
860 /* if comma in password, the string will be
861 prematurely null terminated. Commas in password are
862 specified across the cifs mount interface by a double
863 comma ie ,, and a comma used as in other cases ie ','
864 as a parameter delimiter/separator is single and due
865 to the strsep above is temporarily zeroed. */
866
867 /* NB: password legally can have multiple commas and
868 the only illegal character in a password is null */
869
870 if ((value[temp_len] == 0) &&
871 (value[temp_len+1] == separator[0])) {
872 /* reinsert comma */
873 value[temp_len] = separator[0];
874 temp_len+=2; /* move after the second comma */
875 while(value[temp_len] != 0) {
876 if (value[temp_len] == separator[0]) {
877 if (value[temp_len+1] ==
878 separator[0]) {
879 /* skip second comma */
880 temp_len++;
881 } else {
882 /* single comma indicating start
883 of next parm */
884 break;
885 }
886 }
887 temp_len++;
888 }
889 if(value[temp_len] == 0) {
890 options = NULL;
891 } else {
892 value[temp_len] = 0;
893 /* point option to start of next parm */
894 options = value + temp_len + 1;
895 }
896 /* go from value to value + temp_len condensing
897 double commas to singles. Note that this ends up
898 allocating a few bytes too many, which is ok */
899 vol->password = kzalloc(temp_len, GFP_KERNEL);
900 if(vol->password == NULL) {
901 printk("CIFS: no memory for pass\n");
902 return 1;
903 }
904 for(i=0,j=0;i<temp_len;i++,j++) {
905 vol->password[j] = value[i];
906 if(value[i] == separator[0]
907 && value[i+1] == separator[0]) {
908 /* skip second comma */
909 i++;
910 }
911 }
912 vol->password[j] = 0;
913 } else {
914 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
915 if(vol->password == NULL) {
916 printk("CIFS: no memory for pass\n");
917 return 1;
918 }
919 strcpy(vol->password, value);
920 }
921 } else if (strnicmp(data, "ip", 2) == 0) {
922 if (!value || !*value) {
923 vol->UNCip = NULL;
924 } else if (strnlen(value, 35) < 35) {
925 vol->UNCip = value;
926 } else {
927 printk(KERN_WARNING "CIFS: ip address too long\n");
928 return 1;
929 }
930 } else if (strnicmp(data, "sec", 3) == 0) {
931 if (!value || !*value) {
932 cERROR(1,("no security value specified"));
933 continue;
934 } else if (strnicmp(value, "krb5i", 5) == 0) {
935 vol->secFlg |= CIFSSEC_MAY_KRB5 |
936 CIFSSEC_MUST_SIGN;
937 } else if (strnicmp(value, "krb5p", 5) == 0) {
938 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
939 CIFSSEC_MAY_KRB5; */
940 cERROR(1,("Krb5 cifs privacy not supported"));
941 return 1;
942 } else if (strnicmp(value, "krb5", 4) == 0) {
943 vol->secFlg |= CIFSSEC_MAY_KRB5;
944 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
945 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
946 CIFSSEC_MUST_SIGN;
947 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
948 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
949 } else if (strnicmp(value, "ntlmi", 5) == 0) {
950 vol->secFlg |= CIFSSEC_MAY_NTLM |
951 CIFSSEC_MUST_SIGN;
952 } else if (strnicmp(value, "ntlm", 4) == 0) {
953 /* ntlm is default so can be turned off too */
954 vol->secFlg |= CIFSSEC_MAY_NTLM;
955 } else if (strnicmp(value, "nontlm", 6) == 0) {
956 /* BB is there a better way to do this? */
957 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
958 #ifdef CONFIG_CIFS_WEAK_PW_HASH
959 } else if (strnicmp(value, "lanman", 6) == 0) {
960 vol->secFlg |= CIFSSEC_MAY_LANMAN;
961 #endif
962 } else if (strnicmp(value, "none", 4) == 0) {
963 vol->nullauth = 1;
964 } else {
965 cERROR(1,("bad security option: %s", value));
966 return 1;
967 }
968 } else if ((strnicmp(data, "unc", 3) == 0)
969 || (strnicmp(data, "target", 6) == 0)
970 || (strnicmp(data, "path", 4) == 0)) {
971 if (!value || !*value) {
972 printk(KERN_WARNING
973 "CIFS: invalid path to network resource\n");
974 return 1; /* needs_arg; */
975 }
976 if ((temp_len = strnlen(value, 300)) < 300) {
977 vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
978 if (vol->UNC == NULL)
979 return 1;
980 strcpy(vol->UNC,value);
981 if (strncmp(vol->UNC, "//", 2) == 0) {
982 vol->UNC[0] = '\\';
983 vol->UNC[1] = '\\';
984 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
985 printk(KERN_WARNING
986 "CIFS: UNC Path does not begin with // or \\\\ \n");
987 return 1;
988 }
989 } else {
990 printk(KERN_WARNING "CIFS: UNC name too long\n");
991 return 1;
992 }
993 } else if ((strnicmp(data, "domain", 3) == 0)
994 || (strnicmp(data, "workgroup", 5) == 0)) {
995 if (!value || !*value) {
996 printk(KERN_WARNING "CIFS: invalid domain name\n");
997 return 1; /* needs_arg; */
998 }
999 /* BB are there cases in which a comma can be valid in
1000 a domain name and need special handling? */
1001 if (strnlen(value, 256) < 256) {
1002 vol->domainname = value;
1003 cFYI(1, ("Domain name set"));
1004 } else {
1005 printk(KERN_WARNING "CIFS: domain name too long\n");
1006 return 1;
1007 }
1008 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1009 if (!value || !*value) {
1010 printk(KERN_WARNING
1011 "CIFS: invalid path prefix\n");
1012 return 1; /* needs_arg; */
1013 }
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)
1019 return 1;
1020 if (value[0] != '/') {
1021 vol->prepath[0] = '/';
1022 strcpy(vol->prepath+1,value);
1023 } else
1024 strcpy(vol->prepath,value);
1025 cFYI(1,("prefix path %s",vol->prepath));
1026 } else {
1027 printk(KERN_WARNING "CIFS: prefix too long\n");
1028 return 1;
1029 }
1030 } else if (strnicmp(data, "iocharset", 9) == 0) {
1031 if (!value || !*value) {
1032 printk(KERN_WARNING "CIFS: invalid iocharset specified\n");
1033 return 1; /* needs_arg; */
1034 }
1035 if (strnlen(value, 65) < 65) {
1036 if (strnicmp(value,"default",7))
1037 vol->iocharset = value;
1038 /* if iocharset not set load_nls_default used by caller */
1039 cFYI(1, ("iocharset set to %s",value));
1040 } else {
1041 printk(KERN_WARNING "CIFS: iocharset name too long.\n");
1042 return 1;
1043 }
1044 } else if (strnicmp(data, "uid", 3) == 0) {
1045 if (value && *value) {
1046 vol->linux_uid =
1047 simple_strtoul(value, &value, 0);
1048 vol->override_uid = 1;
1049 }
1050 } else if (strnicmp(data, "gid", 3) == 0) {
1051 if (value && *value) {
1052 vol->linux_gid =
1053 simple_strtoul(value, &value, 0);
1054 vol->override_gid = 1;
1055 }
1056 } else if (strnicmp(data, "file_mode", 4) == 0) {
1057 if (value && *value) {
1058 vol->file_mode =
1059 simple_strtoul(value, &value, 0);
1060 }
1061 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1062 if (value && *value) {
1063 vol->dir_mode =
1064 simple_strtoul(value, &value, 0);
1065 }
1066 } else if (strnicmp(data, "dirmode", 4) == 0) {
1067 if (value && *value) {
1068 vol->dir_mode =
1069 simple_strtoul(value, &value, 0);
1070 }
1071 } else if (strnicmp(data, "port", 4) == 0) {
1072 if (value && *value) {
1073 vol->port =
1074 simple_strtoul(value, &value, 0);
1075 }
1076 } else if (strnicmp(data, "rsize", 5) == 0) {
1077 if (value && *value) {
1078 vol->rsize =
1079 simple_strtoul(value, &value, 0);
1080 }
1081 } else if (strnicmp(data, "wsize", 5) == 0) {
1082 if (value && *value) {
1083 vol->wsize =
1084 simple_strtoul(value, &value, 0);
1085 }
1086 } else if (strnicmp(data, "sockopt", 5) == 0) {
1087 if (value && *value) {
1088 vol->sockopt =
1089 simple_strtoul(value, &value, 0);
1090 }
1091 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1092 if (!value || !*value || (*value == ' ')) {
1093 cFYI(1,("invalid (empty) netbiosname specified"));
1094 } else {
1095 memset(vol->source_rfc1001_name,0x20,15);
1096 for(i=0;i<15;i++) {
1097 /* BB are there cases in which a comma can be
1098 valid in this workstation netbios name (and need
1099 special handling)? */
1100
1101 /* We do not uppercase netbiosname for user */
1102 if (value[i]==0)
1103 break;
1104 else
1105 vol->source_rfc1001_name[i] = value[i];
1106 }
1107 /* The string has 16th byte zero still from
1108 set at top of the function */
1109 if ((i==15) && (value[i] != 0))
1110 printk(KERN_WARNING "CIFS: netbiosname longer than 15 truncated.\n");
1111 }
1112 } else if (strnicmp(data, "servern", 7) == 0) {
1113 /* servernetbiosname specified override *SMBSERVER */
1114 if (!value || !*value || (*value == ' ')) {
1115 cFYI(1,("empty server netbiosname specified"));
1116 } else {
1117 /* last byte, type, is 0x20 for servr type */
1118 memset(vol->target_rfc1001_name,0x20,16);
1119
1120 for(i=0;i<15;i++) {
1121 /* BB are there cases in which a comma can be
1122 valid in this workstation netbios name (and need
1123 special handling)? */
1124
1125 /* user or mount helper must uppercase netbiosname */
1126 if (value[i]==0)
1127 break;
1128 else
1129 vol->target_rfc1001_name[i] = value[i];
1130 }
1131 /* The string has 16th byte zero still from
1132 set at top of the function */
1133 if ((i==15) && (value[i] != 0))
1134 printk(KERN_WARNING "CIFS: server netbiosname longer than 15 truncated.\n");
1135 }
1136 } else if (strnicmp(data, "credentials", 4) == 0) {
1137 /* ignore */
1138 } else if (strnicmp(data, "version", 3) == 0) {
1139 /* ignore */
1140 } else if (strnicmp(data, "guest",5) == 0) {
1141 /* ignore */
1142 } else if (strnicmp(data, "rw", 2) == 0) {
1143 vol->rw = TRUE;
1144 } else if ((strnicmp(data, "suid", 4) == 0) ||
1145 (strnicmp(data, "nosuid", 6) == 0) ||
1146 (strnicmp(data, "exec", 4) == 0) ||
1147 (strnicmp(data, "noexec", 6) == 0) ||
1148 (strnicmp(data, "nodev", 5) == 0) ||
1149 (strnicmp(data, "noauto", 6) == 0) ||
1150 (strnicmp(data, "dev", 3) == 0)) {
1151 /* The mount tool or mount.cifs helper (if present)
1152 uses these opts to set flags, and the flags are read
1153 by the kernel vfs layer before we get here (ie
1154 before read super) so there is no point trying to
1155 parse these options again and set anything and it
1156 is ok to just ignore them */
1157 continue;
1158 } else if (strnicmp(data, "ro", 2) == 0) {
1159 vol->rw = FALSE;
1160 } else if (strnicmp(data, "hard", 4) == 0) {
1161 vol->retry = 1;
1162 } else if (strnicmp(data, "soft", 4) == 0) {
1163 vol->retry = 0;
1164 } else if (strnicmp(data, "perm", 4) == 0) {
1165 vol->noperm = 0;
1166 } else if (strnicmp(data, "noperm", 6) == 0) {
1167 vol->noperm = 1;
1168 } else if (strnicmp(data, "mapchars", 8) == 0) {
1169 vol->remap = 1;
1170 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1171 vol->remap = 0;
1172 } else if (strnicmp(data, "sfu", 3) == 0) {
1173 vol->sfu_emul = 1;
1174 } else if (strnicmp(data, "nosfu", 5) == 0) {
1175 vol->sfu_emul = 0;
1176 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1177 vol->posix_paths = 1;
1178 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1179 vol->posix_paths = 0;
1180 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1181 (strnicmp(data, "ignorecase", 10) == 0)) {
1182 vol->nocase = 1;
1183 } else if (strnicmp(data, "brl", 3) == 0) {
1184 vol->nobrl = 0;
1185 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1186 (strnicmp(data, "nolock", 6) == 0)) {
1187 vol->nobrl = 1;
1188 /* turn off mandatory locking in mode
1189 if remote locking is turned off since the
1190 local vfs will do advisory */
1191 if(vol->file_mode == (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1192 vol->file_mode = S_IALLUGO;
1193 } else if (strnicmp(data, "setuids", 7) == 0) {
1194 vol->setuids = 1;
1195 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1196 vol->setuids = 0;
1197 } else if (strnicmp(data, "nohard", 6) == 0) {
1198 vol->retry = 0;
1199 } else if (strnicmp(data, "nosoft", 6) == 0) {
1200 vol->retry = 1;
1201 } else if (strnicmp(data, "nointr", 6) == 0) {
1202 vol->intr = 0;
1203 } else if (strnicmp(data, "intr", 4) == 0) {
1204 vol->intr = 1;
1205 } else if (strnicmp(data, "serverino",7) == 0) {
1206 vol->server_ino = 1;
1207 } else if (strnicmp(data, "noserverino",9) == 0) {
1208 vol->server_ino = 0;
1209 } else if (strnicmp(data, "cifsacl",7) == 0) {
1210 vol->cifs_acl = 1;
1211 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1212 vol->cifs_acl = 0;
1213 } else if (strnicmp(data, "acl",3) == 0) {
1214 vol->no_psx_acl = 0;
1215 } else if (strnicmp(data, "noacl",5) == 0) {
1216 vol->no_psx_acl = 1;
1217 } else if (strnicmp(data, "sign",4) == 0) {
1218 vol->secFlg |= CIFSSEC_MUST_SIGN;
1219 /* } else if (strnicmp(data, "seal",4) == 0) {
1220 vol->secFlg |= CIFSSEC_MUST_SEAL; */
1221 } else if (strnicmp(data, "direct",6) == 0) {
1222 vol->direct_io = 1;
1223 } else if (strnicmp(data, "forcedirectio",13) == 0) {
1224 vol->direct_io = 1;
1225 } else if (strnicmp(data, "in6_addr",8) == 0) {
1226 if (!value || !*value) {
1227 vol->in6_addr = NULL;
1228 } else if (strnlen(value, 49) == 48) {
1229 vol->in6_addr = value;
1230 } else {
1231 printk(KERN_WARNING "CIFS: ip v6 address not 48 characters long\n");
1232 return 1;
1233 }
1234 } else if (strnicmp(data, "noac", 4) == 0) {
1235 printk(KERN_WARNING "CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1236 } else
1237 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",data);
1238 }
1239 if (vol->UNC == NULL) {
1240 if (devname == NULL) {
1241 printk(KERN_WARNING "CIFS: Missing UNC name for mount target\n");
1242 return 1;
1243 }
1244 if ((temp_len = strnlen(devname, 300)) < 300) {
1245 vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
1246 if (vol->UNC == NULL)
1247 return 1;
1248 strcpy(vol->UNC,devname);
1249 if (strncmp(vol->UNC, "//", 2) == 0) {
1250 vol->UNC[0] = '\\';
1251 vol->UNC[1] = '\\';
1252 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1253 printk(KERN_WARNING "CIFS: UNC Path does not begin with // or \\\\ \n");
1254 return 1;
1255 }
1256 } else {
1257 printk(KERN_WARNING "CIFS: UNC name too long\n");
1258 return 1;
1259 }
1260 }
1261 if(vol->UNCip == NULL)
1262 vol->UNCip = &vol->UNC[2];
1263
1264 return 0;
1265 }
1266
1267 static struct cifsSesInfo *
1268 cifs_find_tcp_session(struct in_addr * target_ip_addr,
1269 struct in6_addr *target_ip6_addr,
1270 char *userName, struct TCP_Server_Info **psrvTcp)
1271 {
1272 struct list_head *tmp;
1273 struct cifsSesInfo *ses;
1274 *psrvTcp = NULL;
1275 read_lock(&GlobalSMBSeslock);
1276
1277 list_for_each(tmp, &GlobalSMBSessionList) {
1278 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
1279 if (ses->server) {
1280 if((target_ip_addr &&
1281 (ses->server->addr.sockAddr.sin_addr.s_addr
1282 == target_ip_addr->s_addr)) || (target_ip6_addr
1283 && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
1284 target_ip6_addr,sizeof(*target_ip6_addr)))){
1285 /* BB lock server and tcp session and increment use count here?? */
1286 *psrvTcp = ses->server; /* found a match on the TCP session */
1287 /* BB check if reconnection needed */
1288 if (strncmp
1289 (ses->userName, userName,
1290 MAX_USERNAME_SIZE) == 0){
1291 read_unlock(&GlobalSMBSeslock);
1292 return ses; /* found exact match on both tcp and SMB sessions */
1293 }
1294 }
1295 }
1296 /* else tcp and smb sessions need reconnection */
1297 }
1298 read_unlock(&GlobalSMBSeslock);
1299 return NULL;
1300 }
1301
1302 static struct cifsTconInfo *
1303 find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
1304 {
1305 struct list_head *tmp;
1306 struct cifsTconInfo *tcon;
1307
1308 read_lock(&GlobalSMBSeslock);
1309 list_for_each(tmp, &GlobalTreeConnectionList) {
1310 cFYI(1, ("Next tcon"));
1311 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
1312 if (tcon->ses) {
1313 if (tcon->ses->server) {
1314 cFYI(1,
1315 ("old ip addr: %x == new ip %x ?",
1316 tcon->ses->server->addr.sockAddr.sin_addr.
1317 s_addr, new_target_ip_addr));
1318 if (tcon->ses->server->addr.sockAddr.sin_addr.
1319 s_addr == new_target_ip_addr) {
1320 /* BB lock tcon, server and tcp session and increment use count here? */
1321 /* found a match on the TCP session */
1322 /* BB check if reconnection needed */
1323 cFYI(1,("IP match, old UNC: %s new: %s",
1324 tcon->treeName, uncName));
1325 if (strncmp
1326 (tcon->treeName, uncName,
1327 MAX_TREE_SIZE) == 0) {
1328 cFYI(1,
1329 ("and old usr: %s new: %s",
1330 tcon->treeName, uncName));
1331 if (strncmp
1332 (tcon->ses->userName,
1333 userName,
1334 MAX_USERNAME_SIZE) == 0) {
1335 read_unlock(&GlobalSMBSeslock);
1336 /* matched smb session
1337 (user name */
1338 return tcon;
1339 }
1340 }
1341 }
1342 }
1343 }
1344 }
1345 read_unlock(&GlobalSMBSeslock);
1346 return NULL;
1347 }
1348
1349 int
1350 connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1351 const char *old_path, const struct nls_table *nls_codepage,
1352 int remap)
1353 {
1354 unsigned char *referrals = NULL;
1355 unsigned int num_referrals;
1356 int rc = 0;
1357
1358 rc = get_dfs_path(xid, pSesInfo,old_path, nls_codepage,
1359 &num_referrals, &referrals, remap);
1360
1361 /* BB Add in code to: if valid refrl, if not ip address contact
1362 the helper that resolves tcp names, mount to it, try to
1363 tcon to it unmount it if fail */
1364
1365 kfree(referrals);
1366
1367 return rc;
1368 }
1369
1370 int
1371 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
1372 const char *old_path, const struct nls_table *nls_codepage,
1373 unsigned int *pnum_referrals,
1374 unsigned char ** preferrals, int remap)
1375 {
1376 char *temp_unc;
1377 int rc = 0;
1378
1379 *pnum_referrals = 0;
1380
1381 if (pSesInfo->ipc_tid == 0) {
1382 temp_unc = kmalloc(2 /* for slashes */ +
1383 strnlen(pSesInfo->serverName,SERVER_NAME_LEN_WITH_NULL * 2)
1384 + 1 + 4 /* slash IPC$ */ + 2,
1385 GFP_KERNEL);
1386 if (temp_unc == NULL)
1387 return -ENOMEM;
1388 temp_unc[0] = '\\';
1389 temp_unc[1] = '\\';
1390 strcpy(temp_unc + 2, pSesInfo->serverName);
1391 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1392 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1393 cFYI(1,
1394 ("CIFS Tcon rc = %d ipc_tid = %d", rc,pSesInfo->ipc_tid));
1395 kfree(temp_unc);
1396 }
1397 if (rc == 0)
1398 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1399 pnum_referrals, nls_codepage, remap);
1400
1401 return rc;
1402 }
1403
1404 /* See RFC1001 section 14 on representation of Netbios names */
1405 static void rfc1002mangle(char * target,char * source, unsigned int length)
1406 {
1407 unsigned int i,j;
1408
1409 for(i=0,j=0;i<(length);i++) {
1410 /* mask a nibble at a time and encode */
1411 target[j] = 'A' + (0x0F & (source[i] >> 4));
1412 target[j+1] = 'A' + (0x0F & source[i]);
1413 j+=2;
1414 }
1415
1416 }
1417
1418
1419 static int
1420 ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
1421 char * netbios_name, char * target_name)
1422 {
1423 int rc = 0;
1424 int connected = 0;
1425 __be16 orig_port = 0;
1426
1427 if(*csocket == NULL) {
1428 rc = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, csocket);
1429 if (rc < 0) {
1430 cERROR(1, ("Error %d creating socket",rc));
1431 *csocket = NULL;
1432 return rc;
1433 } else {
1434 /* BB other socket options to set KEEPALIVE, NODELAY? */
1435 cFYI(1,("Socket created"));
1436 (*csocket)->sk->sk_allocation = GFP_NOFS;
1437 }
1438 }
1439
1440 psin_server->sin_family = AF_INET;
1441 if(psin_server->sin_port) { /* user overrode default port */
1442 rc = (*csocket)->ops->connect(*csocket,
1443 (struct sockaddr *) psin_server,
1444 sizeof (struct sockaddr_in),0);
1445 if (rc >= 0)
1446 connected = 1;
1447 }
1448
1449 if(!connected) {
1450 /* save original port so we can retry user specified port
1451 later if fall back ports fail this time */
1452 orig_port = psin_server->sin_port;
1453
1454 /* do not retry on the same port we just failed on */
1455 if(psin_server->sin_port != htons(CIFS_PORT)) {
1456 psin_server->sin_port = htons(CIFS_PORT);
1457
1458 rc = (*csocket)->ops->connect(*csocket,
1459 (struct sockaddr *) psin_server,
1460 sizeof (struct sockaddr_in),0);
1461 if (rc >= 0)
1462 connected = 1;
1463 }
1464 }
1465 if (!connected) {
1466 psin_server->sin_port = htons(RFC1001_PORT);
1467 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1468 psin_server, sizeof (struct sockaddr_in),0);
1469 if (rc >= 0)
1470 connected = 1;
1471 }
1472
1473 /* give up here - unless we want to retry on different
1474 protocol families some day */
1475 if (!connected) {
1476 if(orig_port)
1477 psin_server->sin_port = orig_port;
1478 cFYI(1,("Error %d connecting to server via ipv4",rc));
1479 sock_release(*csocket);
1480 *csocket = NULL;
1481 return rc;
1482 }
1483 /* Eventually check for other socket options to change from
1484 the default. sock_setsockopt not used because it expects
1485 user space buffer */
1486 cFYI(1,("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",(*csocket)->sk->sk_sndbuf,
1487 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
1488 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1489 /* make the bufsizes depend on wsize/rsize and max requests */
1490 if((*csocket)->sk->sk_sndbuf < (200 * 1024))
1491 (*csocket)->sk->sk_sndbuf = 200 * 1024;
1492 if((*csocket)->sk->sk_rcvbuf < (140 * 1024))
1493 (*csocket)->sk->sk_rcvbuf = 140 * 1024;
1494
1495 /* send RFC1001 sessinit */
1496 if(psin_server->sin_port == htons(RFC1001_PORT)) {
1497 /* some servers require RFC1001 sessinit before sending
1498 negprot - BB check reconnection in case where second
1499 sessinit is sent but no second negprot */
1500 struct rfc1002_session_packet * ses_init_buf;
1501 struct smb_hdr * smb_buf;
1502 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet), GFP_KERNEL);
1503 if(ses_init_buf) {
1504 ses_init_buf->trailer.session_req.called_len = 32;
1505 if(target_name && (target_name[0] != 0)) {
1506 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1507 target_name, 16);
1508 } else {
1509 rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
1510 DEFAULT_CIFS_CALLED_NAME,16);
1511 }
1512
1513 ses_init_buf->trailer.session_req.calling_len = 32;
1514 /* calling name ends in null (byte 16) from old smb
1515 convention. */
1516 if(netbios_name && (netbios_name[0] !=0)) {
1517 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1518 netbios_name,16);
1519 } else {
1520 rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
1521 "LINUX_CIFS_CLNT",16);
1522 }
1523 ses_init_buf->trailer.session_req.scope1 = 0;
1524 ses_init_buf->trailer.session_req.scope2 = 0;
1525 smb_buf = (struct smb_hdr *)ses_init_buf;
1526 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1527 smb_buf->smb_buf_length = 0x81000044;
1528 rc = smb_send(*csocket, smb_buf, 0x44,
1529 (struct sockaddr *)psin_server);
1530 kfree(ses_init_buf);
1531 msleep(1); /* RFC1001 layer in at least one server
1532 requires very short break before negprot
1533 presumably because not expecting negprot
1534 to follow so fast. This is a simple
1535 solution that works without
1536 complicating the code and causes no
1537 significant slowing down on mount
1538 for everyone else */
1539 }
1540 /* else the negprot may still work without this
1541 even though malloc failed */
1542
1543 }
1544
1545 return rc;
1546 }
1547
1548 static int
1549 ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
1550 {
1551 int rc = 0;
1552 int connected = 0;
1553 __be16 orig_port = 0;
1554
1555 if(*csocket == NULL) {
1556 rc = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, csocket);
1557 if (rc < 0) {
1558 cERROR(1, ("Error %d creating ipv6 socket",rc));
1559 *csocket = NULL;
1560 return rc;
1561 } else {
1562 /* BB other socket options to set KEEPALIVE, NODELAY? */
1563 cFYI(1,("ipv6 Socket created"));
1564 (*csocket)->sk->sk_allocation = GFP_NOFS;
1565 }
1566 }
1567
1568 psin_server->sin6_family = AF_INET6;
1569
1570 if(psin_server->sin6_port) { /* user overrode default port */
1571 rc = (*csocket)->ops->connect(*csocket,
1572 (struct sockaddr *) psin_server,
1573 sizeof (struct sockaddr_in6),0);
1574 if (rc >= 0)
1575 connected = 1;
1576 }
1577
1578 if(!connected) {
1579 /* save original port so we can retry user specified port
1580 later if fall back ports fail this time */
1581
1582 orig_port = psin_server->sin6_port;
1583 /* do not retry on the same port we just failed on */
1584 if(psin_server->sin6_port != htons(CIFS_PORT)) {
1585 psin_server->sin6_port = htons(CIFS_PORT);
1586
1587 rc = (*csocket)->ops->connect(*csocket,
1588 (struct sockaddr *) psin_server,
1589 sizeof (struct sockaddr_in6),0);
1590 if (rc >= 0)
1591 connected = 1;
1592 }
1593 }
1594 if (!connected) {
1595 psin_server->sin6_port = htons(RFC1001_PORT);
1596 rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
1597 psin_server, sizeof (struct sockaddr_in6),0);
1598 if (rc >= 0)
1599 connected = 1;
1600 }
1601
1602 /* give up here - unless we want to retry on different
1603 protocol families some day */
1604 if (!connected) {
1605 if(orig_port)
1606 psin_server->sin6_port = orig_port;
1607 cFYI(1,("Error %d connecting to server via ipv6",rc));
1608 sock_release(*csocket);
1609 *csocket = NULL;
1610 return rc;
1611 }
1612 /* Eventually check for other socket options to change from
1613 the default. sock_setsockopt not used because it expects
1614 user space buffer */
1615 (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
1616
1617 return rc;
1618 }
1619
1620 void reset_cifs_unix_caps(int xid, struct cifsTconInfo * tcon,
1621 struct super_block * sb, struct smb_vol * vol_info)
1622 {
1623 /* if we are reconnecting then should we check to see if
1624 * any requested capabilities changed locally e.g. via
1625 * remount but we can not do much about it here
1626 * if they have (even if we could detect it by the following)
1627 * Perhaps we could add a backpointer to array of sb from tcon
1628 * or if we change to make all sb to same share the same
1629 * sb as NFS - then we only have one backpointer to sb.
1630 * What if we wanted to mount the server share twice once with
1631 * and once without posixacls or posix paths? */
1632 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1633
1634
1635 if(!CIFSSMBQFSUnixInfo(xid, tcon)) {
1636 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1637
1638 /* check for reconnect case in which we do not
1639 want to change the mount behavior if we can avoid it */
1640 if(vol_info == NULL) {
1641 /* turn off POSIX ACL and PATHNAMES if not set
1642 originally at mount time */
1643 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1644 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1645 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
1646 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1647
1648
1649
1650
1651 }
1652
1653 cap &= CIFS_UNIX_CAP_MASK;
1654 if(vol_info && vol_info->no_psx_acl)
1655 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1656 else if(CIFS_UNIX_POSIX_ACL_CAP & cap) {
1657 cFYI(1,("negotiated posix acl support"));
1658 if(sb)
1659 sb->s_flags |= MS_POSIXACL;
1660 }
1661
1662 if(vol_info && vol_info->posix_paths == 0)
1663 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1664 else if(cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
1665 cFYI(1,("negotiate posix pathnames"));
1666 if(sb)
1667 CIFS_SB(sb)->mnt_cifs_flags |=
1668 CIFS_MOUNT_POSIX_PATHS;
1669 }
1670
1671 /* We might be setting the path sep back to a different
1672 form if we are reconnecting and the server switched its
1673 posix path capability for this share */
1674 if(sb && (CIFS_SB(sb)->prepathlen > 0))
1675 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
1676
1677 cFYI(1,("Negotiate caps 0x%x",(int)cap));
1678 #ifdef CONFIG_CIFS_DEBUG2
1679 if(cap & CIFS_UNIX_FCNTL_CAP)
1680 cFYI(1,("FCNTL cap"));
1681 if(cap & CIFS_UNIX_EXTATTR_CAP)
1682 cFYI(1,("EXTATTR cap"));
1683 if(cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1684 cFYI(1,("POSIX path cap"));
1685 if(cap & CIFS_UNIX_XATTR_CAP)
1686 cFYI(1,("XATTR cap"));
1687 if(cap & CIFS_UNIX_POSIX_ACL_CAP)
1688 cFYI(1,("POSIX ACL cap"));
1689 #endif /* CIFS_DEBUG2 */
1690 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
1691 cFYI(1,("setting capabilities failed"));
1692 }
1693 }
1694 }
1695
1696 int
1697 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
1698 char *mount_data, const char *devname)
1699 {
1700 int rc = 0;
1701 int xid;
1702 int address_type = AF_INET;
1703 struct socket *csocket = NULL;
1704 struct sockaddr_in sin_server;
1705 struct sockaddr_in6 sin_server6;
1706 struct smb_vol volume_info;
1707 struct cifsSesInfo *pSesInfo = NULL;
1708 struct cifsSesInfo *existingCifsSes = NULL;
1709 struct cifsTconInfo *tcon = NULL;
1710 struct TCP_Server_Info *srvTcp = NULL;
1711
1712 xid = GetXid();
1713
1714 /* cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); */
1715
1716 memset(&volume_info,0,sizeof(struct smb_vol));
1717 if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
1718 kfree(volume_info.UNC);
1719 kfree(volume_info.password);
1720 kfree(volume_info.prepath);
1721 FreeXid(xid);
1722 return -EINVAL;
1723 }
1724
1725 if (volume_info.nullauth) {
1726 cFYI(1,("null user"));
1727 volume_info.username = NULL;
1728 } else if (volume_info.username) {
1729 /* BB fixme parse for domain name here */
1730 cFYI(1, ("Username: %s ", volume_info.username));
1731 } else {
1732 cifserror("No username specified");
1733 /* In userspace mount helper we can get user name from alternate
1734 locations such as env variables and files on disk */
1735 kfree(volume_info.UNC);
1736 kfree(volume_info.password);
1737 kfree(volume_info.prepath);
1738 FreeXid(xid);
1739 return -EINVAL;
1740 }
1741
1742 if (volume_info.UNCip && volume_info.UNC) {
1743 rc = cifs_inet_pton(AF_INET, volume_info.UNCip,&sin_server.sin_addr.s_addr);
1744
1745 if(rc <= 0) {
1746 /* not ipv4 address, try ipv6 */
1747 rc = cifs_inet_pton(AF_INET6,volume_info.UNCip,&sin_server6.sin6_addr.in6_u);
1748 if(rc > 0)
1749 address_type = AF_INET6;
1750 } else {
1751 address_type = AF_INET;
1752 }
1753
1754 if(rc <= 0) {
1755 /* we failed translating address */
1756 kfree(volume_info.UNC);
1757 kfree(volume_info.password);
1758 kfree(volume_info.prepath);
1759 FreeXid(xid);
1760 return -EINVAL;
1761 }
1762
1763 cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
1764 /* success */
1765 rc = 0;
1766 } else if (volume_info.UNCip){
1767 /* BB using ip addr as server name connect to the DFS root below */
1768 cERROR(1,("Connecting to DFS root not implemented yet"));
1769 kfree(volume_info.UNC);
1770 kfree(volume_info.password);
1771 kfree(volume_info.prepath);
1772 FreeXid(xid);
1773 return -EINVAL;
1774 } else /* which servers DFS root would we conect to */ {
1775 cERROR(1,
1776 ("CIFS mount error: No UNC path (e.g. -o unc=//192.168.1.100/public) specified"));
1777 kfree(volume_info.UNC);
1778 kfree(volume_info.password);
1779 kfree(volume_info.prepath);
1780 FreeXid(xid);
1781 return -EINVAL;
1782 }
1783
1784 /* this is needed for ASCII cp to Unicode converts */
1785 if(volume_info.iocharset == NULL) {
1786 cifs_sb->local_nls = load_nls_default();
1787 /* load_nls_default can not return null */
1788 } else {
1789 cifs_sb->local_nls = load_nls(volume_info.iocharset);
1790 if(cifs_sb->local_nls == NULL) {
1791 cERROR(1,("CIFS mount error: iocharset %s not found",volume_info.iocharset));
1792 kfree(volume_info.UNC);
1793 kfree(volume_info.password);
1794 kfree(volume_info.prepath);
1795 FreeXid(xid);
1796 return -ELIBACC;
1797 }
1798 }
1799
1800 if(address_type == AF_INET)
1801 existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
1802 NULL /* no ipv6 addr */,
1803 volume_info.username, &srvTcp);
1804 else if(address_type == AF_INET6) {
1805 cFYI(1,("looking for ipv6 address"));
1806 existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
1807 &sin_server6.sin6_addr,
1808 volume_info.username, &srvTcp);
1809 } else {
1810 kfree(volume_info.UNC);
1811 kfree(volume_info.password);
1812 kfree(volume_info.prepath);
1813 FreeXid(xid);
1814 return -EINVAL;
1815 }
1816
1817
1818 if (srvTcp) {
1819 cFYI(1, ("Existing tcp session with server found"));
1820 } else { /* create socket */
1821 if (volume_info.port)
1822 sin_server.sin_port = htons(volume_info.port);
1823 else
1824 sin_server.sin_port = 0;
1825 if (address_type == AF_INET6) {
1826 cFYI(1,("attempting ipv6 connect"));
1827 /* BB should we allow ipv6 on port 139? */
1828 /* other OS never observed in Wild doing 139 with v6 */
1829 rc = ipv6_connect(&sin_server6,&csocket);
1830 } else
1831 rc = ipv4_connect(&sin_server,&csocket,
1832 volume_info.source_rfc1001_name,
1833 volume_info.target_rfc1001_name);
1834 if (rc < 0) {
1835 cERROR(1,
1836 ("Error connecting to IPv4 socket. Aborting operation"));
1837 if (csocket != NULL)
1838 sock_release(csocket);
1839 kfree(volume_info.UNC);
1840 kfree(volume_info.password);
1841 kfree(volume_info.prepath);
1842 FreeXid(xid);
1843 return rc;
1844 }
1845
1846 srvTcp = kmalloc(sizeof (struct TCP_Server_Info), GFP_KERNEL);
1847 if (srvTcp == NULL) {
1848 rc = -ENOMEM;
1849 sock_release(csocket);
1850 kfree(volume_info.UNC);
1851 kfree(volume_info.password);
1852 kfree(volume_info.prepath);
1853 FreeXid(xid);
1854 return rc;
1855 } else {
1856 memset(srvTcp, 0, sizeof (struct TCP_Server_Info));
1857 memcpy(&srvTcp->addr.sockAddr, &sin_server, sizeof (struct sockaddr_in));
1858 atomic_set(&srvTcp->inFlight,0);
1859 /* BB Add code for ipv6 case too */
1860 srvTcp->ssocket = csocket;
1861 srvTcp->protocolType = IPV4;
1862 init_waitqueue_head(&srvTcp->response_q);
1863 init_waitqueue_head(&srvTcp->request_q);
1864 INIT_LIST_HEAD(&srvTcp->pending_mid_q);
1865 /* at this point we are the only ones with the pointer
1866 to the struct since the kernel thread not created yet
1867 so no need to spinlock this init of tcpStatus */
1868 srvTcp->tcpStatus = CifsNew;
1869 init_MUTEX(&srvTcp->tcpSem);
1870 srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
1871 if ( IS_ERR(srvTcp->tsk) ) {
1872 rc = PTR_ERR(srvTcp->tsk);
1873 cERROR(1,("error %d create cifsd thread", rc));
1874 srvTcp->tsk = NULL;
1875 sock_release(csocket);
1876 kfree(volume_info.UNC);
1877 kfree(volume_info.password);
1878 kfree(volume_info.prepath);
1879 FreeXid(xid);
1880 return rc;
1881 }
1882 wait_for_completion(&cifsd_complete);
1883 rc = 0;
1884 memcpy(srvTcp->workstation_RFC1001_name, volume_info.source_rfc1001_name,16);
1885 memcpy(srvTcp->server_RFC1001_name, volume_info.target_rfc1001_name,16);
1886 srvTcp->sequence_number = 0;
1887 }
1888 }
1889
1890 if (existingCifsSes) {
1891 pSesInfo = existingCifsSes;
1892 cFYI(1, ("Existing smb sess found"));
1893 kfree(volume_info.password);
1894 /* volume_info.UNC freed at end of function */
1895 } else if (!rc) {
1896 cFYI(1, ("Existing smb sess not found"));
1897 pSesInfo = sesInfoAlloc();
1898 if (pSesInfo == NULL)
1899 rc = -ENOMEM;
1900 else {
1901 pSesInfo->server = srvTcp;
1902 sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
1903 NIPQUAD(sin_server.sin_addr.s_addr));
1904 }
1905
1906 if (!rc){
1907 /* volume_info.password freed at unmount */
1908 if (volume_info.password)
1909 pSesInfo->password = volume_info.password;
1910 if (volume_info.username)
1911 strncpy(pSesInfo->userName,
1912 volume_info.username,MAX_USERNAME_SIZE);
1913 if (volume_info.domainname) {
1914 int len = strlen(volume_info.domainname);
1915 pSesInfo->domainName =
1916 kmalloc(len + 1, GFP_KERNEL);
1917 if (pSesInfo->domainName)
1918 strcpy(pSesInfo->domainName,
1919 volume_info.domainname);
1920 }
1921 pSesInfo->linux_uid = volume_info.linux_uid;
1922 pSesInfo->overrideSecFlg = volume_info.secFlg;
1923 down(&pSesInfo->sesSem);
1924 /* BB FIXME need to pass vol->secFlgs BB */
1925 rc = cifs_setup_session(xid,pSesInfo, cifs_sb->local_nls);
1926 up(&pSesInfo->sesSem);
1927 if (!rc)
1928 atomic_inc(&srvTcp->socketUseCount);
1929 } else
1930 kfree(volume_info.password);
1931 }
1932
1933 /* search for existing tcon to this server share */
1934 if (!rc) {
1935 if (volume_info.rsize > CIFSMaxBufSize) {
1936 cERROR(1,("rsize %d too large, using MaxBufSize",
1937 volume_info.rsize));
1938 cifs_sb->rsize = CIFSMaxBufSize;
1939 } else if((volume_info.rsize) && (volume_info.rsize <= CIFSMaxBufSize))
1940 cifs_sb->rsize = volume_info.rsize;
1941 else /* default */
1942 cifs_sb->rsize = CIFSMaxBufSize;
1943
1944 if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
1945 cERROR(1,("wsize %d too large using 4096 instead",
1946 volume_info.wsize));
1947 cifs_sb->wsize = 4096;
1948 } else if (volume_info.wsize)
1949 cifs_sb->wsize = volume_info.wsize;
1950 else
1951 cifs_sb->wsize =
1952 min_t(const int, PAGEVEC_SIZE * PAGE_CACHE_SIZE,
1953 127*1024);
1954 /* old default of CIFSMaxBufSize was too small now
1955 that SMB Write2 can send multiple pages in kvec.
1956 RFC1001 does not describe what happens when frame
1957 bigger than 128K is sent so use that as max in
1958 conjunction with 52K kvec constraint on arch with 4K
1959 page size */
1960
1961 if (cifs_sb->rsize < 2048) {
1962 cifs_sb->rsize = 2048;
1963 /* Windows ME may prefer this */
1964 cFYI(1,("readsize set to minimum 2048"));
1965 }
1966 /* calculate prepath */
1967 cifs_sb->prepath = volume_info.prepath;
1968 if (cifs_sb->prepath) {
1969 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
1970 cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
1971 volume_info.prepath = NULL;
1972 } else
1973 cifs_sb->prepathlen = 0;
1974 cifs_sb->mnt_uid = volume_info.linux_uid;
1975 cifs_sb->mnt_gid = volume_info.linux_gid;
1976 cifs_sb->mnt_file_mode = volume_info.file_mode;
1977 cifs_sb->mnt_dir_mode = volume_info.dir_mode;
1978 cFYI(1,("file mode: 0x%x dir mode: 0x%x",
1979 cifs_sb->mnt_file_mode,cifs_sb->mnt_dir_mode));
1980
1981 if (volume_info.noperm)
1982 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1983 if (volume_info.setuids)
1984 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1985 if (volume_info.server_ino)
1986 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1987 if (volume_info.remap)
1988 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1989 if (volume_info.no_xattr)
1990 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1991 if (volume_info.sfu_emul)
1992 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1993 if (volume_info.nobrl)
1994 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1995 if (volume_info.cifs_acl)
1996 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1997 if (volume_info.override_uid)
1998 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1999 if (volume_info.override_gid)
2000 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2001 if (volume_info.direct_io) {
2002 cFYI(1,("mounting share using direct i/o"));
2003 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2004 }
2005
2006 tcon =
2007 find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
2008 volume_info.username);
2009 if (tcon) {
2010 cFYI(1, ("Found match on UNC path"));
2011 /* we can have only one retry value for a connection
2012 to a share so for resources mounted more than once
2013 to the same server share the last value passed in
2014 for the retry flag is used */
2015 tcon->retry = volume_info.retry;
2016 tcon->nocase = volume_info.nocase;
2017 } else {
2018 tcon = tconInfoAlloc();
2019 if (tcon == NULL)
2020 rc = -ENOMEM;
2021 else {
2022 /* check for null share name ie connecting to
2023 * dfs root */
2024
2025 /* BB check if this works for exactly length
2026 * three strings */
2027 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
2028 && (strchr(volume_info.UNC + 3, '/') ==
2029 NULL)) {
2030 rc = connect_to_dfs_path(xid, pSesInfo,
2031 "", cifs_sb->local_nls,
2032 cifs_sb->mnt_cifs_flags &
2033 CIFS_MOUNT_MAP_SPECIAL_CHR);
2034 kfree(volume_info.UNC);
2035 FreeXid(xid);
2036 return -ENODEV;
2037 } else {
2038 /* BB Do we need to wrap sesSem around
2039 * this TCon call and Unix SetFS as
2040 * we do on SessSetup and reconnect? */
2041 rc = CIFSTCon(xid, pSesInfo,
2042 volume_info.UNC,
2043 tcon, cifs_sb->local_nls);
2044 cFYI(1, ("CIFS Tcon rc = %d", rc));
2045 }
2046 if (!rc) {
2047 atomic_inc(&pSesInfo->inUse);
2048 tcon->retry = volume_info.retry;
2049 tcon->nocase = volume_info.nocase;
2050 }
2051 }
2052 }
2053 }
2054 if (pSesInfo) {
2055 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2056 sb->s_maxbytes = (u64) 1 << 63;
2057 } else
2058 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2059 }
2060
2061 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2062 sb->s_time_gran = 100;
2063
2064 /* on error free sesinfo and tcon struct if needed */
2065 if (rc) {
2066 /* if session setup failed, use count is zero but
2067 we still need to free cifsd thread */
2068 if (atomic_read(&srvTcp->socketUseCount) == 0) {
2069 spin_lock(&GlobalMid_Lock);
2070 srvTcp->tcpStatus = CifsExiting;
2071 spin_unlock(&GlobalMid_Lock);
2072 if (srvTcp->tsk) {
2073 struct task_struct *tsk;
2074 /* If we could verify that kthread_stop would
2075 always wake up processes blocked in
2076 tcp in recv_mesg then we could remove the
2077 send_sig call */
2078 send_sig(SIGKILL,srvTcp->tsk,1);
2079 tsk = srvTcp->tsk;
2080 if(tsk)
2081 kthread_stop(tsk);
2082 }
2083 }
2084 /* If find_unc succeeded then rc == 0 so we can not end */
2085 if (tcon) /* up accidently freeing someone elses tcon struct */
2086 tconInfoFree(tcon);
2087 if (existingCifsSes == NULL) {
2088 if (pSesInfo) {
2089 if ((pSesInfo->server) &&
2090 (pSesInfo->status == CifsGood)) {
2091 int temp_rc;
2092 temp_rc = CIFSSMBLogoff(xid, pSesInfo);
2093 /* if the socketUseCount is now zero */
2094 if ((temp_rc == -ESHUTDOWN) &&
2095 (pSesInfo->server) && (pSesInfo->server->tsk)) {
2096 struct task_struct *tsk;
2097 send_sig(SIGKILL,pSesInfo->server->tsk,1);
2098 tsk = pSesInfo->server->tsk;
2099 if (tsk)
2100 kthread_stop(tsk);
2101 }
2102 } else
2103 cFYI(1, ("No session or bad tcon"));
2104 sesInfoFree(pSesInfo);
2105 /* pSesInfo = NULL; */
2106 }
2107 }
2108 } else {
2109 atomic_inc(&tcon->useCount);
2110 cifs_sb->tcon = tcon;
2111 tcon->ses = pSesInfo;
2112
2113 /* do not care if following two calls succeed - informational */
2114 CIFSSMBQFSDeviceInfo(xid, tcon);
2115 CIFSSMBQFSAttributeInfo(xid, tcon);
2116
2117 /* tell server which Unix caps we support */
2118 if (tcon->ses->capabilities & CAP_UNIX)
2119 reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
2120
2121 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2122 cifs_sb->wsize = min(cifs_sb->wsize,
2123 (tcon->ses->server->maxBuf -
2124 MAX_CIFS_HDR_SIZE));
2125 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2126 cifs_sb->rsize = min(cifs_sb->rsize,
2127 (tcon->ses->server->maxBuf -
2128 MAX_CIFS_HDR_SIZE));
2129 }
2130
2131 /* volume_info.password is freed above when existing session found
2132 (in which case it is not needed anymore) but when new sesion is created
2133 the password ptr is put in the new session structure (in which case the
2134 password will be freed at unmount time) */
2135 kfree(volume_info.UNC);
2136 kfree(volume_info.prepath);
2137 FreeXid(xid);
2138 return rc;
2139 }
2140
2141 static int
2142 CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2143 char session_key[CIFS_SESS_KEY_SIZE],
2144 const struct nls_table *nls_codepage)
2145 {
2146 struct smb_hdr *smb_buffer;
2147 struct smb_hdr *smb_buffer_response;
2148 SESSION_SETUP_ANDX *pSMB;
2149 SESSION_SETUP_ANDX *pSMBr;
2150 char *bcc_ptr;
2151 char *user;
2152 char *domain;
2153 int rc = 0;
2154 int remaining_words = 0;
2155 int bytes_returned = 0;
2156 int len;
2157 __u32 capabilities;
2158 __u16 count;
2159
2160 cFYI(1, ("In sesssetup"));
2161 if (ses == NULL)
2162 return -EINVAL;
2163 user = ses->userName;
2164 domain = ses->domainName;
2165 smb_buffer = cifs_buf_get();
2166 if (smb_buffer == NULL) {
2167 return -ENOMEM;
2168 }
2169 smb_buffer_response = smb_buffer;
2170 pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2171
2172 /* send SMBsessionSetup here */
2173 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2174 NULL /* no tCon exists yet */ , 13 /* wct */ );
2175
2176 smb_buffer->Mid = GetNextMid(ses->server);
2177 pSMB->req_no_secext.AndXCommand = 0xFF;
2178 pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2179 pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2180
2181 if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2182 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2183
2184 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2185 CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
2186 if (ses->capabilities & CAP_UNICODE) {
2187 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2188 capabilities |= CAP_UNICODE;
2189 }
2190 if (ses->capabilities & CAP_STATUS32) {
2191 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2192 capabilities |= CAP_STATUS32;
2193 }
2194 if (ses->capabilities & CAP_DFS) {
2195 smb_buffer->Flags2 |= SMBFLG2_DFS;
2196 capabilities |= CAP_DFS;
2197 }
2198 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
2199
2200 pSMB->req_no_secext.CaseInsensitivePasswordLength =
2201 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2202
2203 pSMB->req_no_secext.CaseSensitivePasswordLength =
2204 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2205 bcc_ptr = pByteArea(smb_buffer);
2206 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2207 bcc_ptr += CIFS_SESS_KEY_SIZE;
2208 memcpy(bcc_ptr, (char *) session_key, CIFS_SESS_KEY_SIZE);
2209 bcc_ptr += CIFS_SESS_KEY_SIZE;
2210
2211 if (ses->capabilities & CAP_UNICODE) {
2212 if ((long) bcc_ptr % 2) { /* must be word aligned for Unicode */
2213 *bcc_ptr = 0;
2214 bcc_ptr++;
2215 }
2216 if (user == NULL)
2217 bytes_returned = 0; /* skip null user */
2218 else
2219 bytes_returned =
2220 cifs_strtoUCS((__le16 *) bcc_ptr, user, 100,
2221 nls_codepage);
2222 /* convert number of 16 bit words to bytes */
2223 bcc_ptr += 2 * bytes_returned;
2224 bcc_ptr += 2; /* trailing null */
2225 if (domain == NULL)
2226 bytes_returned =
2227 cifs_strtoUCS((__le16 *) bcc_ptr,
2228 "CIFS_LINUX_DOM", 32, nls_codepage);
2229 else
2230 bytes_returned =
2231 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2232 nls_codepage);
2233 bcc_ptr += 2 * bytes_returned;
2234 bcc_ptr += 2;
2235 bytes_returned =
2236 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2237 32, nls_codepage);
2238 bcc_ptr += 2 * bytes_returned;
2239 bytes_returned =
2240 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release,
2241 32, nls_codepage);
2242 bcc_ptr += 2 * bytes_returned;
2243 bcc_ptr += 2;
2244 bytes_returned =
2245 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2246 64, nls_codepage);
2247 bcc_ptr += 2 * bytes_returned;
2248 bcc_ptr += 2;
2249 } else {
2250 if (user != NULL) {
2251 strncpy(bcc_ptr, user, 200);
2252 bcc_ptr += strnlen(user, 200);
2253 }
2254 *bcc_ptr = 0;
2255 bcc_ptr++;
2256 if (domain == NULL) {
2257 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
2258 bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
2259 } else {
2260 strncpy(bcc_ptr, domain, 64);
2261 bcc_ptr += strnlen(domain, 64);
2262 *bcc_ptr = 0;
2263 bcc_ptr++;
2264 }
2265 strcpy(bcc_ptr, "Linux version ");
2266 bcc_ptr += strlen("Linux version ");
2267 strcpy(bcc_ptr, utsname()->release);
2268 bcc_ptr += strlen(utsname()->release) + 1;
2269 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2270 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2271 }
2272 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2273 smb_buffer->smb_buf_length += count;
2274 pSMB->req_no_secext.ByteCount = cpu_to_le16(count);
2275
2276 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2277 &bytes_returned, 1);
2278 if (rc) {
2279 /* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
2280 } else if ((smb_buffer_response->WordCount == 3)
2281 || (smb_buffer_response->WordCount == 4)) {
2282 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2283 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2284 if (action & GUEST_LOGIN)
2285 cFYI(1, (" Guest login")); /* do we want to mark SesInfo struct ? */
2286 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format (le) */
2287 cFYI(1, ("UID = %d ", ses->Suid));
2288 /* response can have either 3 or 4 word count - Samba sends 3 */
2289 bcc_ptr = pByteArea(smb_buffer_response);
2290 if ((pSMBr->resp.hdr.WordCount == 3)
2291 || ((pSMBr->resp.hdr.WordCount == 4)
2292 && (blob_len < pSMBr->resp.ByteCount))) {
2293 if (pSMBr->resp.hdr.WordCount == 4)
2294 bcc_ptr += blob_len;
2295
2296 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2297 if ((long) (bcc_ptr) % 2) {
2298 remaining_words =
2299 (BCC(smb_buffer_response) - 1) /2;
2300 bcc_ptr++; /* Unicode strings must be word aligned */
2301 } else {
2302 remaining_words =
2303 BCC(smb_buffer_response) / 2;
2304 }
2305 len =
2306 UniStrnlen((wchar_t *) bcc_ptr,
2307 remaining_words - 1);
2308 /* We look for obvious messed up bcc or strings in response so we do not go off
2309 the end since (at least) WIN2K and Windows XP have a major bug in not null
2310 terminating last Unicode string in response */
2311 if(ses->serverOS)
2312 kfree(ses->serverOS);
2313 ses->serverOS = kzalloc(2 * (len + 1), GFP_KERNEL);
2314 if(ses->serverOS == NULL)
2315 goto sesssetup_nomem;
2316 cifs_strfromUCS_le(ses->serverOS,
2317 (__le16 *)bcc_ptr, len,nls_codepage);
2318 bcc_ptr += 2 * (len + 1);
2319 remaining_words -= len + 1;
2320 ses->serverOS[2 * len] = 0;
2321 ses->serverOS[1 + (2 * len)] = 0;
2322 if (remaining_words > 0) {
2323 len = UniStrnlen((wchar_t *)bcc_ptr,
2324 remaining_words-1);
2325 kfree(ses->serverNOS);
2326 ses->serverNOS = kzalloc(2 * (len + 1),GFP_KERNEL);
2327 if(ses->serverNOS == NULL)
2328 goto sesssetup_nomem;
2329 cifs_strfromUCS_le(ses->serverNOS,
2330 (__le16 *)bcc_ptr,len,nls_codepage);
2331 bcc_ptr += 2 * (len + 1);
2332 ses->serverNOS[2 * len] = 0;
2333 ses->serverNOS[1 + (2 * len)] = 0;
2334 if(strncmp(ses->serverNOS,
2335 "NT LAN Manager 4",16) == 0) {
2336 cFYI(1,("NT4 server"));
2337 ses->flags |= CIFS_SES_NT4;
2338 }
2339 remaining_words -= len + 1;
2340 if (remaining_words > 0) {
2341 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2342 /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
2343 if(ses->serverDomain)
2344 kfree(ses->serverDomain);
2345 ses->serverDomain =
2346 kzalloc(2*(len+1),GFP_KERNEL);
2347 if(ses->serverDomain == NULL)
2348 goto sesssetup_nomem;
2349 cifs_strfromUCS_le(ses->serverDomain,
2350 (__le16 *)bcc_ptr,len,nls_codepage);
2351 bcc_ptr += 2 * (len + 1);
2352 ses->serverDomain[2*len] = 0;
2353 ses->serverDomain[1+(2*len)] = 0;
2354 } /* else no more room so create dummy domain string */
2355 else {
2356 if(ses->serverDomain)
2357 kfree(ses->serverDomain);
2358 ses->serverDomain =
2359 kzalloc(2, GFP_KERNEL);
2360 }
2361 } else { /* no room so create dummy domain and NOS string */
2362 /* if these kcallocs fail not much we
2363 can do, but better to not fail the
2364 sesssetup itself */
2365 kfree(ses->serverDomain);
2366 ses->serverDomain =
2367 kzalloc(2, GFP_KERNEL);
2368 kfree(ses->serverNOS);
2369 ses->serverNOS =
2370 kzalloc(2, GFP_KERNEL);
2371 }
2372 } else { /* ASCII */
2373 len = strnlen(bcc_ptr, 1024);
2374 if (((long) bcc_ptr + len) - (long)
2375 pByteArea(smb_buffer_response)
2376 <= BCC(smb_buffer_response)) {
2377 kfree(ses->serverOS);
2378 ses->serverOS = kzalloc(len + 1,GFP_KERNEL);
2379 if(ses->serverOS == NULL)
2380 goto sesssetup_nomem;
2381 strncpy(ses->serverOS,bcc_ptr, len);
2382
2383 bcc_ptr += len;
2384 bcc_ptr[0] = 0; /* null terminate the string */
2385 bcc_ptr++;
2386
2387 len = strnlen(bcc_ptr, 1024);
2388 kfree(ses->serverNOS);
2389 ses->serverNOS = kzalloc(len + 1,GFP_KERNEL);
2390 if(ses->serverNOS == NULL)
2391 goto sesssetup_nomem;
2392 strncpy(ses->serverNOS, bcc_ptr, len);
2393 bcc_ptr += len;
2394 bcc_ptr[0] = 0;
2395 bcc_ptr++;
2396
2397 len = strnlen(bcc_ptr, 1024);
2398 if(ses->serverDomain)
2399 kfree(ses->serverDomain);
2400 ses->serverDomain = kzalloc(len + 1,GFP_KERNEL);
2401 if(ses->serverDomain == NULL)
2402 goto sesssetup_nomem;
2403 strncpy(ses->serverDomain, bcc_ptr, len);
2404 bcc_ptr += len;
2405 bcc_ptr[0] = 0;
2406 bcc_ptr++;
2407 } else
2408 cFYI(1,
2409 ("Variable field of length %d extends beyond end of smb ",
2410 len));
2411 }
2412 } else {
2413 cERROR(1,
2414 (" Security Blob Length extends beyond end of SMB"));
2415 }
2416 } else {
2417 cERROR(1,
2418 (" Invalid Word count %d: ",
2419 smb_buffer_response->WordCount));
2420 rc = -EIO;
2421 }
2422 sesssetup_nomem: /* do not return an error on nomem for the info strings,
2423 since that could make reconnection harder, and
2424 reconnection might be needed to free memory */
2425 if (smb_buffer)
2426 cifs_buf_release(smb_buffer);
2427
2428 return rc;
2429 }
2430
2431 static int
2432 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
2433 struct cifsSesInfo *ses, int * pNTLMv2_flag,
2434 const struct nls_table *nls_codepage)
2435 {
2436 struct smb_hdr *smb_buffer;
2437 struct smb_hdr *smb_buffer_response;
2438 SESSION_SETUP_ANDX *pSMB;
2439 SESSION_SETUP_ANDX *pSMBr;
2440 char *bcc_ptr;
2441 char *domain;
2442 int rc = 0;
2443 int remaining_words = 0;
2444 int bytes_returned = 0;
2445 int len;
2446 int SecurityBlobLength = sizeof (NEGOTIATE_MESSAGE);
2447 PNEGOTIATE_MESSAGE SecurityBlob;
2448 PCHALLENGE_MESSAGE SecurityBlob2;
2449 __u32 negotiate_flags, capabilities;
2450 __u16 count;
2451
2452 cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
2453 if(ses == NULL)
2454 return -EINVAL;
2455 domain = ses->domainName;
2456 *pNTLMv2_flag = FALSE;
2457 smb_buffer = cifs_buf_get();
2458 if (smb_buffer == NULL) {
2459 return -ENOMEM;
2460 }
2461 smb_buffer_response = smb_buffer;
2462 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2463 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2464
2465 /* send SMBsessionSetup here */
2466 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2467 NULL /* no tCon exists yet */ , 12 /* wct */ );
2468
2469 smb_buffer->Mid = GetNextMid(ses->server);
2470 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2471 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2472
2473 pSMB->req.AndXCommand = 0xFF;
2474 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2475 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2476
2477 if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2478 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2479
2480 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2481 CAP_EXTENDED_SECURITY;
2482 if (ses->capabilities & CAP_UNICODE) {
2483 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2484 capabilities |= CAP_UNICODE;
2485 }
2486 if (ses->capabilities & CAP_STATUS32) {
2487 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2488 capabilities |= CAP_STATUS32;
2489 }
2490 if (ses->capabilities & CAP_DFS) {
2491 smb_buffer->Flags2 |= SMBFLG2_DFS;
2492 capabilities |= CAP_DFS;
2493 }
2494 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2495
2496 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2497 SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
2498 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2499 SecurityBlob->MessageType = NtLmNegotiate;
2500 negotiate_flags =
2501 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
2502 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
2503 NTLMSSP_NEGOTIATE_56 |
2504 /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
2505 if(sign_CIFS_PDUs)
2506 negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
2507 /* if(ntlmv2_support)
2508 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
2509 /* setup pointers to domain name and workstation name */
2510 bcc_ptr += SecurityBlobLength;
2511
2512 SecurityBlob->WorkstationName.Buffer = 0;
2513 SecurityBlob->WorkstationName.Length = 0;
2514 SecurityBlob->WorkstationName.MaximumLength = 0;
2515
2516 /* Domain not sent on first Sesssetup in NTLMSSP, instead it is sent
2517 along with username on auth request (ie the response to challenge) */
2518 SecurityBlob->DomainName.Buffer = 0;
2519 SecurityBlob->DomainName.Length = 0;
2520 SecurityBlob->DomainName.MaximumLength = 0;
2521 if (ses->capabilities & CAP_UNICODE) {
2522 if ((long) bcc_ptr % 2) {
2523 *bcc_ptr = 0;
2524 bcc_ptr++;
2525 }
2526
2527 bytes_returned =
2528 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2529 32, nls_codepage);
2530 bcc_ptr += 2 * bytes_returned;
2531 bytes_returned =
2532 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2533 nls_codepage);
2534 bcc_ptr += 2 * bytes_returned;
2535 bcc_ptr += 2; /* null terminate Linux version */
2536 bytes_returned =
2537 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2538 64, nls_codepage);
2539 bcc_ptr += 2 * bytes_returned;
2540 *(bcc_ptr + 1) = 0;
2541 *(bcc_ptr + 2) = 0;
2542 bcc_ptr += 2; /* null terminate network opsys string */
2543 *(bcc_ptr + 1) = 0;
2544 *(bcc_ptr + 2) = 0;
2545 bcc_ptr += 2; /* null domain */
2546 } else { /* ASCII */
2547 strcpy(bcc_ptr, "Linux version ");
2548 bcc_ptr += strlen("Linux version ");
2549 strcpy(bcc_ptr, utsname()->release);
2550 bcc_ptr += strlen(utsname()->release) + 1;
2551 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2552 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2553 bcc_ptr++; /* empty domain field */
2554 *bcc_ptr = 0;
2555 }
2556 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2557 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2558 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2559 smb_buffer->smb_buf_length += count;
2560 pSMB->req.ByteCount = cpu_to_le16(count);
2561
2562 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2563 &bytes_returned, 1);
2564
2565 if (smb_buffer_response->Status.CifsError ==
2566 cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
2567 rc = 0;
2568
2569 if (rc) {
2570 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2571 } else if ((smb_buffer_response->WordCount == 3)
2572 || (smb_buffer_response->WordCount == 4)) {
2573 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2574 __u16 blob_len = le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2575
2576 if (action & GUEST_LOGIN)
2577 cFYI(1, (" Guest login"));
2578 /* Do we want to set anything in SesInfo struct when guest login? */
2579
2580 bcc_ptr = pByteArea(smb_buffer_response);
2581 /* response can have either 3 or 4 word count - Samba sends 3 */
2582
2583 SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
2584 if (SecurityBlob2->MessageType != NtLmChallenge) {
2585 cFYI(1,
2586 ("Unexpected NTLMSSP message type received %d",
2587 SecurityBlob2->MessageType));
2588 } else if (ses) {
2589 ses->Suid = smb_buffer_response->Uid; /* UID left in le format */
2590 cFYI(1, ("UID = %d", ses->Suid));
2591 if ((pSMBr->resp.hdr.WordCount == 3)
2592 || ((pSMBr->resp.hdr.WordCount == 4)
2593 && (blob_len <
2594 pSMBr->resp.ByteCount))) {
2595
2596 if (pSMBr->resp.hdr.WordCount == 4) {
2597 bcc_ptr += blob_len;
2598 cFYI(1, ("Security Blob Length %d",
2599 blob_len));
2600 }
2601
2602 cFYI(1, ("NTLMSSP Challenge rcvd"));
2603
2604 memcpy(ses->server->cryptKey,
2605 SecurityBlob2->Challenge,
2606 CIFS_CRYPTO_KEY_SIZE);
2607 if(SecurityBlob2->NegotiateFlags &
2608 cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
2609 *pNTLMv2_flag = TRUE;
2610
2611 if((SecurityBlob2->NegotiateFlags &
2612 cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
2613 || (sign_CIFS_PDUs > 1))
2614 ses->server->secMode |=
2615 SECMODE_SIGN_REQUIRED;
2616 if ((SecurityBlob2->NegotiateFlags &
2617 cpu_to_le32(NTLMSSP_NEGOTIATE_SIGN)) && (sign_CIFS_PDUs))
2618 ses->server->secMode |=
2619 SECMODE_SIGN_ENABLED;
2620
2621 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
2622 if ((long) (bcc_ptr) % 2) {
2623 remaining_words =
2624 (BCC(smb_buffer_response)
2625 - 1) / 2;
2626 bcc_ptr++; /* Unicode strings must be word aligned */
2627 } else {
2628 remaining_words =
2629 BCC
2630 (smb_buffer_response) / 2;
2631 }
2632 len =
2633 UniStrnlen((wchar_t *) bcc_ptr,
2634 remaining_words - 1);
2635 /* We look for obvious messed up bcc or strings in response so we do not go off
2636 the end since (at least) WIN2K and Windows XP have a major bug in not null
2637 terminating last Unicode string in response */
2638 if(ses->serverOS)
2639 kfree(ses->serverOS);
2640 ses->serverOS =
2641 kzalloc(2 * (len + 1), GFP_KERNEL);
2642 cifs_strfromUCS_le(ses->serverOS,
2643 (__le16 *)
2644 bcc_ptr, len,
2645 nls_codepage);
2646 bcc_ptr += 2 * (len + 1);
2647 remaining_words -= len + 1;
2648 ses->serverOS[2 * len] = 0;
2649 ses->serverOS[1 + (2 * len)] = 0;
2650 if (remaining_words > 0) {
2651 len = UniStrnlen((wchar_t *)
2652 bcc_ptr,
2653 remaining_words
2654 - 1);
2655 kfree(ses->serverNOS);
2656 ses->serverNOS =
2657 kzalloc(2 * (len + 1),
2658 GFP_KERNEL);
2659 cifs_strfromUCS_le(ses->
2660 serverNOS,
2661 (__le16 *)
2662 bcc_ptr,
2663 len,
2664 nls_codepage);
2665 bcc_ptr += 2 * (len + 1);
2666 ses->serverNOS[2 * len] = 0;
2667 ses->serverNOS[1 +
2668 (2 * len)] = 0;
2669 remaining_words -= len + 1;
2670 if (remaining_words > 0) {
2671 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
2672 /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
2673 kfree(ses->serverDomain);
2674 ses->serverDomain =
2675 kzalloc(2 *
2676 (len +
2677 1),
2678 GFP_KERNEL);
2679 cifs_strfromUCS_le
2680 (ses->serverDomain,
2681 (__le16 *)bcc_ptr,
2682 len, nls_codepage);
2683 bcc_ptr +=
2684 2 * (len + 1);
2685 ses->serverDomain[2*len]
2686 = 0;
2687 ses->serverDomain
2688 [1 + (2 * len)]
2689 = 0;
2690 } /* else no more room so create dummy domain string */
2691 else {
2692 kfree(ses->serverDomain);
2693 ses->serverDomain =
2694 kzalloc(2,
2695 GFP_KERNEL);
2696 }
2697 } else { /* no room so create dummy domain and NOS string */
2698 kfree(ses->serverDomain);
2699 ses->serverDomain =
2700 kzalloc(2, GFP_KERNEL);
2701 kfree(ses->serverNOS);
2702 ses->serverNOS =
2703 kzalloc(2, GFP_KERNEL);
2704 }
2705 } else { /* ASCII */
2706 len = strnlen(bcc_ptr, 1024);
2707 if (((long) bcc_ptr + len) - (long)
2708 pByteArea(smb_buffer_response)
2709 <= BCC(smb_buffer_response)) {
2710 if(ses->serverOS)
2711 kfree(ses->serverOS);
2712 ses->serverOS =
2713 kzalloc(len + 1,
2714 GFP_KERNEL);
2715 strncpy(ses->serverOS,
2716 bcc_ptr, len);
2717
2718 bcc_ptr += len;
2719 bcc_ptr[0] = 0; /* null terminate string */
2720 bcc_ptr++;
2721
2722 len = strnlen(bcc_ptr, 1024);
2723 kfree(ses->serverNOS);
2724 ses->serverNOS =
2725 kzalloc(len + 1,
2726 GFP_KERNEL);
2727 strncpy(ses->serverNOS, bcc_ptr, len);
2728 bcc_ptr += len;
2729 bcc_ptr[0] = 0;
2730 bcc_ptr++;
2731
2732 len = strnlen(bcc_ptr, 1024);
2733 kfree(ses->serverDomain);
2734 ses->serverDomain =
2735 kzalloc(len + 1,
2736 GFP_KERNEL);
2737 strncpy(ses->serverDomain, bcc_ptr, len);
2738 bcc_ptr += len;
2739 bcc_ptr[0] = 0;
2740 bcc_ptr++;
2741 } else
2742 cFYI(1,
2743 ("Variable field of length %d extends beyond end of smb",
2744 len));
2745 }
2746 } else {
2747 cERROR(1,
2748 (" Security Blob Length extends beyond end of SMB"));
2749 }
2750 } else {
2751 cERROR(1, ("No session structure passed in."));
2752 }
2753 } else {
2754 cERROR(1,
2755 (" Invalid Word count %d:",
2756 smb_buffer_response->WordCount));
2757 rc = -EIO;
2758 }
2759
2760 if (smb_buffer)
2761 cifs_buf_release(smb_buffer);
2762
2763 return rc;
2764 }
2765 static int
2766 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
2767 char *ntlm_session_key, int ntlmv2_flag,
2768 const struct nls_table *nls_codepage)
2769 {
2770 struct smb_hdr *smb_buffer;
2771 struct smb_hdr *smb_buffer_response;
2772 SESSION_SETUP_ANDX *pSMB;
2773 SESSION_SETUP_ANDX *pSMBr;
2774 char *bcc_ptr;
2775 char *user;
2776 char *domain;
2777 int rc = 0;
2778 int remaining_words = 0;
2779 int bytes_returned = 0;
2780 int len;
2781 int SecurityBlobLength = sizeof (AUTHENTICATE_MESSAGE);
2782 PAUTHENTICATE_MESSAGE SecurityBlob;
2783 __u32 negotiate_flags, capabilities;
2784 __u16 count;
2785
2786 cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
2787 if(ses == NULL)
2788 return -EINVAL;
2789 user = ses->userName;
2790 domain = ses->domainName;
2791 smb_buffer = cifs_buf_get();
2792 if (smb_buffer == NULL) {
2793 return -ENOMEM;
2794 }
2795 smb_buffer_response = smb_buffer;
2796 pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
2797 pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
2798
2799 /* send SMBsessionSetup here */
2800 header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
2801 NULL /* no tCon exists yet */ , 12 /* wct */ );
2802
2803 smb_buffer->Mid = GetNextMid(ses->server);
2804 pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
2805 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
2806 pSMB->req.AndXCommand = 0xFF;
2807 pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
2808 pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
2809
2810 pSMB->req.hdr.Uid = ses->Suid;
2811
2812 if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2813 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2814
2815 capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
2816 CAP_EXTENDED_SECURITY;
2817 if (ses->capabilities & CAP_UNICODE) {
2818 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2819 capabilities |= CAP_UNICODE;
2820 }
2821 if (ses->capabilities & CAP_STATUS32) {
2822 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2823 capabilities |= CAP_STATUS32;
2824 }
2825 if (ses->capabilities & CAP_DFS) {
2826 smb_buffer->Flags2 |= SMBFLG2_DFS;
2827 capabilities |= CAP_DFS;
2828 }
2829 pSMB->req.Capabilities = cpu_to_le32(capabilities);
2830
2831 bcc_ptr = (char *) &pSMB->req.SecurityBlob;
2832 SecurityBlob = (PAUTHENTICATE_MESSAGE) bcc_ptr;
2833 strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
2834 SecurityBlob->MessageType = NtLmAuthenticate;
2835 bcc_ptr += SecurityBlobLength;
2836 negotiate_flags =
2837 NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
2838 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
2839 0x80000000 | NTLMSSP_NEGOTIATE_128;
2840 if(sign_CIFS_PDUs)
2841 negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
2842 if(ntlmv2_flag)
2843 negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
2844
2845 /* setup pointers to domain name and workstation name */
2846
2847 SecurityBlob->WorkstationName.Buffer = 0;
2848 SecurityBlob->WorkstationName.Length = 0;
2849 SecurityBlob->WorkstationName.MaximumLength = 0;
2850 SecurityBlob->SessionKey.Length = 0;
2851 SecurityBlob->SessionKey.MaximumLength = 0;
2852 SecurityBlob->SessionKey.Buffer = 0;
2853
2854 SecurityBlob->LmChallengeResponse.Length = 0;
2855 SecurityBlob->LmChallengeResponse.MaximumLength = 0;
2856 SecurityBlob->LmChallengeResponse.Buffer = 0;
2857
2858 SecurityBlob->NtChallengeResponse.Length =
2859 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2860 SecurityBlob->NtChallengeResponse.MaximumLength =
2861 cpu_to_le16(CIFS_SESS_KEY_SIZE);
2862 memcpy(bcc_ptr, ntlm_session_key, CIFS_SESS_KEY_SIZE);
2863 SecurityBlob->NtChallengeResponse.Buffer =
2864 cpu_to_le32(SecurityBlobLength);
2865 SecurityBlobLength += CIFS_SESS_KEY_SIZE;
2866 bcc_ptr += CIFS_SESS_KEY_SIZE;
2867
2868 if (ses->capabilities & CAP_UNICODE) {
2869 if (domain == NULL) {
2870 SecurityBlob->DomainName.Buffer = 0;
2871 SecurityBlob->DomainName.Length = 0;
2872 SecurityBlob->DomainName.MaximumLength = 0;
2873 } else {
2874 __u16 len =
2875 cifs_strtoUCS((__le16 *) bcc_ptr, domain, 64,
2876 nls_codepage);
2877 len *= 2;
2878 SecurityBlob->DomainName.MaximumLength =
2879 cpu_to_le16(len);
2880 SecurityBlob->DomainName.Buffer =
2881 cpu_to_le32(SecurityBlobLength);
2882 bcc_ptr += len;
2883 SecurityBlobLength += len;
2884 SecurityBlob->DomainName.Length =
2885 cpu_to_le16(len);
2886 }
2887 if (user == NULL) {
2888 SecurityBlob->UserName.Buffer = 0;
2889 SecurityBlob->UserName.Length = 0;
2890 SecurityBlob->UserName.MaximumLength = 0;
2891 } else {
2892 __u16 len =
2893 cifs_strtoUCS((__le16 *) bcc_ptr, user, 64,
2894 nls_codepage);
2895 len *= 2;
2896 SecurityBlob->UserName.MaximumLength =
2897 cpu_to_le16(len);
2898 SecurityBlob->UserName.Buffer =
2899 cpu_to_le32(SecurityBlobLength);
2900 bcc_ptr += len;
2901 SecurityBlobLength += len;
2902 SecurityBlob->UserName.Length =
2903 cpu_to_le16(len);
2904 }
2905
2906 /* SecurityBlob->WorkstationName.Length = cifs_strtoUCS((__le16 *) bcc_ptr, "AMACHINE",64, nls_codepage);
2907 SecurityBlob->WorkstationName.Length *= 2;
2908 SecurityBlob->WorkstationName.MaximumLength = cpu_to_le16(SecurityBlob->WorkstationName.Length);
2909 SecurityBlob->WorkstationName.Buffer = cpu_to_le32(SecurityBlobLength);
2910 bcc_ptr += SecurityBlob->WorkstationName.Length;
2911 SecurityBlobLength += SecurityBlob->WorkstationName.Length;
2912 SecurityBlob->WorkstationName.Length = cpu_to_le16(SecurityBlob->WorkstationName.Length); */
2913
2914 if ((long) bcc_ptr % 2) {
2915 *bcc_ptr = 0;
2916 bcc_ptr++;
2917 }
2918 bytes_returned =
2919 cifs_strtoUCS((__le16 *) bcc_ptr, "Linux version ",
2920 32, nls_codepage);
2921 bcc_ptr += 2 * bytes_returned;
2922 bytes_returned =
2923 cifs_strtoUCS((__le16 *) bcc_ptr, utsname()->release, 32,
2924 nls_codepage);
2925 bcc_ptr += 2 * bytes_returned;
2926 bcc_ptr += 2; /* null term version string */
2927 bytes_returned =
2928 cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
2929 64, nls_codepage);
2930 bcc_ptr += 2 * bytes_returned;
2931 *(bcc_ptr + 1) = 0;
2932 *(bcc_ptr + 2) = 0;
2933 bcc_ptr += 2; /* null terminate network opsys string */
2934 *(bcc_ptr + 1) = 0;
2935 *(bcc_ptr + 2) = 0;
2936 bcc_ptr += 2; /* null domain */
2937 } else { /* ASCII */
2938 if (domain == NULL) {
2939 SecurityBlob->DomainName.Buffer = 0;
2940 SecurityBlob->DomainName.Length = 0;
2941 SecurityBlob->DomainName.MaximumLength = 0;
2942 } else {
2943 __u16 len;
2944 negotiate_flags |= NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
2945 strncpy(bcc_ptr, domain, 63);
2946 len = strnlen(domain, 64);
2947 SecurityBlob->DomainName.MaximumLength =
2948 cpu_to_le16(len);
2949 SecurityBlob->DomainName.Buffer =
2950 cpu_to_le32(SecurityBlobLength);
2951 bcc_ptr += len;
2952 SecurityBlobLength += len;
2953 SecurityBlob->DomainName.Length = cpu_to_le16(len);
2954 }
2955 if (user == NULL) {
2956 SecurityBlob->UserName.Buffer = 0;
2957 SecurityBlob->UserName.Length = 0;
2958 SecurityBlob->UserName.MaximumLength = 0;
2959 } else {
2960 __u16 len;
2961 strncpy(bcc_ptr, user, 63);
2962 len = strnlen(user, 64);
2963 SecurityBlob->UserName.MaximumLength =
2964 cpu_to_le16(len);
2965 SecurityBlob->UserName.Buffer =
2966 cpu_to_le32(SecurityBlobLength);
2967 bcc_ptr += len;
2968 SecurityBlobLength += len;
2969 SecurityBlob->UserName.Length = cpu_to_le16(len);
2970 }
2971 /* BB fill in our workstation name if known BB */
2972
2973 strcpy(bcc_ptr, "Linux version ");
2974 bcc_ptr += strlen("Linux version ");
2975 strcpy(bcc_ptr, utsname()->release);
2976 bcc_ptr += strlen(utsname()->release) + 1;
2977 strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
2978 bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
2979 bcc_ptr++; /* null domain */
2980 *bcc_ptr = 0;
2981 }
2982 SecurityBlob->NegotiateFlags = cpu_to_le32(negotiate_flags);
2983 pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
2984 count = (long) bcc_ptr - (long) pByteArea(smb_buffer);
2985 smb_buffer->smb_buf_length += count;
2986 pSMB->req.ByteCount = cpu_to_le16(count);
2987
2988 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
2989 &bytes_returned, 1);
2990 if (rc) {
2991 /* rc = map_smb_to_linux_error(smb_buffer_response); *//* done in SendReceive now */
2992 } else if ((smb_buffer_response->WordCount == 3)
2993 || (smb_buffer_response->WordCount == 4)) {
2994 __u16 action = le16_to_cpu(pSMBr->resp.Action);
2995 __u16 blob_len =
2996 le16_to_cpu(pSMBr->resp.SecurityBlobLength);
2997 if (action & GUEST_LOGIN)
2998 cFYI(1, (" Guest login")); /* BB do we want to set anything in SesInfo struct ? */
2999 /* if(SecurityBlob2->MessageType != NtLm??){
3000 cFYI("Unexpected message type on auth response is %d "));
3001 } */
3002 if (ses) {
3003 cFYI(1,
3004 ("Does UID on challenge %d match auth response UID %d ",
3005 ses->Suid, smb_buffer_response->Uid));
3006 ses->Suid = smb_buffer_response->Uid; /* UID left in wire format */
3007 bcc_ptr = pByteArea(smb_buffer_response);
3008 /* response can have either 3 or 4 word count - Samba sends 3 */
3009 if ((pSMBr->resp.hdr.WordCount == 3)
3010 || ((pSMBr->resp.hdr.WordCount == 4)
3011 && (blob_len <
3012 pSMBr->resp.ByteCount))) {
3013 if (pSMBr->resp.hdr.WordCount == 4) {
3014 bcc_ptr +=
3015 blob_len;
3016 cFYI(1,
3017 ("Security Blob Length %d ",
3018 blob_len));
3019 }
3020
3021 cFYI(1,
3022 ("NTLMSSP response to Authenticate "));
3023
3024 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3025 if ((long) (bcc_ptr) % 2) {
3026 remaining_words =
3027 (BCC(smb_buffer_response)
3028 - 1) / 2;
3029 bcc_ptr++; /* Unicode strings must be word aligned */
3030 } else {
3031 remaining_words = BCC(smb_buffer_response) / 2;
3032 }
3033 len =
3034 UniStrnlen((wchar_t *) bcc_ptr,remaining_words - 1);
3035 /* We look for obvious messed up bcc or strings in response so we do not go off
3036 the end since (at least) WIN2K and Windows XP have a major bug in not null
3037 terminating last Unicode string in response */
3038 if(ses->serverOS)
3039 kfree(ses->serverOS);
3040 ses->serverOS =
3041 kzalloc(2 * (len + 1), GFP_KERNEL);
3042 cifs_strfromUCS_le(ses->serverOS,
3043 (__le16 *)
3044 bcc_ptr, len,
3045 nls_codepage);
3046 bcc_ptr += 2 * (len + 1);
3047 remaining_words -= len + 1;
3048 ses->serverOS[2 * len] = 0;
3049 ses->serverOS[1 + (2 * len)] = 0;
3050 if (remaining_words > 0) {
3051 len = UniStrnlen((wchar_t *)
3052 bcc_ptr,
3053 remaining_words
3054 - 1);
3055 kfree(ses->serverNOS);
3056 ses->serverNOS =
3057 kzalloc(2 * (len + 1),
3058 GFP_KERNEL);
3059 cifs_strfromUCS_le(ses->
3060 serverNOS,
3061 (__le16 *)
3062 bcc_ptr,
3063 len,
3064 nls_codepage);
3065 bcc_ptr += 2 * (len + 1);
3066 ses->serverNOS[2 * len] = 0;
3067 ses->serverNOS[1+(2*len)] = 0;
3068 remaining_words -= len + 1;
3069 if (remaining_words > 0) {
3070 len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
3071 /* last string not always null terminated (e.g. for Windows XP & 2000) */
3072 if(ses->serverDomain)
3073 kfree(ses->serverDomain);
3074 ses->serverDomain =
3075 kzalloc(2 *
3076 (len +
3077 1),
3078 GFP_KERNEL);
3079 cifs_strfromUCS_le
3080 (ses->
3081 serverDomain,
3082 (__le16 *)
3083 bcc_ptr, len,
3084 nls_codepage);
3085 bcc_ptr +=
3086 2 * (len + 1);
3087 ses->
3088 serverDomain[2
3089 * len]
3090 = 0;
3091 ses->
3092 serverDomain[1
3093 +
3094 (2
3095 *
3096 len)]
3097 = 0;
3098 } /* else no more room so create dummy domain string */
3099 else {
3100 if(ses->serverDomain)
3101 kfree(ses->serverDomain);
3102 ses->serverDomain = kzalloc(2,GFP_KERNEL);
3103 }
3104 } else { /* no room so create dummy domain and NOS string */
3105 if(ses->serverDomain)
3106 kfree(ses->serverDomain);
3107 ses->serverDomain = kzalloc(2, GFP_KERNEL);
3108 kfree(ses->serverNOS);
3109 ses->serverNOS = kzalloc(2, GFP_KERNEL);
3110 }
3111 } else { /* ASCII */
3112 len = strnlen(bcc_ptr, 1024);
3113 if (((long) bcc_ptr + len) -
3114 (long) pByteArea(smb_buffer_response)
3115 <= BCC(smb_buffer_response)) {
3116 if(ses->serverOS)
3117 kfree(ses->serverOS);
3118 ses->serverOS = kzalloc(len + 1,GFP_KERNEL);
3119 strncpy(ses->serverOS,bcc_ptr, len);
3120
3121 bcc_ptr += len;
3122 bcc_ptr[0] = 0; /* null terminate the string */
3123 bcc_ptr++;
3124
3125 len = strnlen(bcc_ptr, 1024);
3126 kfree(ses->serverNOS);
3127 ses->serverNOS = kzalloc(len+1,GFP_KERNEL);
3128 strncpy(ses->serverNOS, bcc_ptr, len);
3129 bcc_ptr += len;
3130 bcc_ptr[0] = 0;
3131 bcc_ptr++;
3132
3133 len = strnlen(bcc_ptr, 1024);
3134 if(ses->serverDomain)
3135 kfree(ses->serverDomain);
3136 ses->serverDomain = kzalloc(len+1,GFP_KERNEL);
3137 strncpy(ses->serverDomain, bcc_ptr, len);
3138 bcc_ptr += len;
3139 bcc_ptr[0] = 0;
3140 bcc_ptr++;
3141 } else
3142 cFYI(1,
3143 ("Variable field of length %d extends beyond end of smb ",
3144 len));
3145 }
3146 } else {
3147 cERROR(1,
3148 (" Security Blob Length extends beyond end of SMB"));
3149 }
3150 } else {
3151 cERROR(1, ("No session structure passed in."));
3152 }
3153 } else {
3154 cERROR(1,
3155 (" Invalid Word count %d: ",
3156 smb_buffer_response->WordCount));
3157 rc = -EIO;
3158 }
3159
3160 if (smb_buffer)
3161 cifs_buf_release(smb_buffer);
3162
3163 return rc;
3164 }
3165
3166 int
3167 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3168 const char *tree, struct cifsTconInfo *tcon,
3169 const struct nls_table *nls_codepage)
3170 {
3171 struct smb_hdr *smb_buffer;
3172 struct smb_hdr *smb_buffer_response;
3173 TCONX_REQ *pSMB;
3174 TCONX_RSP *pSMBr;
3175 unsigned char *bcc_ptr;
3176 int rc = 0;
3177 int length;
3178 __u16 count;
3179
3180 if (ses == NULL)
3181 return -EIO;
3182
3183 smb_buffer = cifs_buf_get();
3184 if (smb_buffer == NULL) {
3185 return -ENOMEM;
3186 }
3187 smb_buffer_response = smb_buffer;
3188
3189 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3190 NULL /*no tid */ , 4 /*wct */ );
3191
3192 smb_buffer->Mid = GetNextMid(ses->server);
3193 smb_buffer->Uid = ses->Suid;
3194 pSMB = (TCONX_REQ *) smb_buffer;
3195 pSMBr = (TCONX_RSP *) smb_buffer_response;
3196
3197 pSMB->AndXCommand = 0xFF;
3198 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3199 bcc_ptr = &pSMB->Password[0];
3200 if((ses->server->secMode) & SECMODE_USER) {
3201 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3202 *bcc_ptr = 0; /* password is null byte */
3203 bcc_ptr++; /* skip password */
3204 /* already aligned so no need to do it below */
3205 } else {
3206 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
3207 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3208 specified as required (when that support is added to
3209 the vfs in the future) as only NTLM or the much
3210 weaker LANMAN (which we do not send by default) is accepted
3211 by Samba (not sure whether other servers allow
3212 NTLMv2 password here) */
3213 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3214 if((extended_security & CIFSSEC_MAY_LANMAN) &&
3215 (ses->server->secType == LANMAN))
3216 calc_lanman_hash(ses, bcc_ptr);
3217 else
3218 #endif /* CIFS_WEAK_PW_HASH */
3219 SMBNTencrypt(ses->password,
3220 ses->server->cryptKey,
3221 bcc_ptr);
3222
3223 bcc_ptr += CIFS_SESS_KEY_SIZE;
3224 if(ses->capabilities & CAP_UNICODE) {
3225 /* must align unicode strings */
3226 *bcc_ptr = 0; /* null byte password */
3227 bcc_ptr++;
3228 }
3229 }
3230
3231 if(ses->server->secMode &
3232 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3233 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3234
3235 if (ses->capabilities & CAP_STATUS32) {
3236 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3237 }
3238 if (ses->capabilities & CAP_DFS) {
3239 smb_buffer->Flags2 |= SMBFLG2_DFS;
3240 }
3241 if (ses->capabilities & CAP_UNICODE) {
3242 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3243 length =
3244 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3245 6 /* max utf8 char length in bytes */ *
3246 (/* server len*/ + 256 /* share len */), nls_codepage);
3247 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3248 bcc_ptr += 2; /* skip trailing null */
3249 } else { /* ASCII */
3250 strcpy(bcc_ptr, tree);
3251 bcc_ptr += strlen(tree) + 1;
3252 }
3253 strcpy(bcc_ptr, "?????");
3254 bcc_ptr += strlen("?????");
3255 bcc_ptr += 1;
3256 count = bcc_ptr - &pSMB->Password[0];
3257 pSMB->hdr.smb_buf_length += count;
3258 pSMB->ByteCount = cpu_to_le16(count);
3259
3260 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length, 0);
3261
3262 /* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
3263 /* above now done in SendReceive */
3264 if ((rc == 0) && (tcon != NULL)) {
3265 tcon->tidStatus = CifsGood;
3266 tcon->tid = smb_buffer_response->Tid;
3267 bcc_ptr = pByteArea(smb_buffer_response);
3268 length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
3269 /* skip service field (NB: this field is always ASCII) */
3270 bcc_ptr += length + 1;
3271 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3272 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
3273 length = UniStrnlen((wchar_t *) bcc_ptr, 512);
3274 if ((bcc_ptr + (2 * length)) -
3275 pByteArea(smb_buffer_response) <=
3276 BCC(smb_buffer_response)) {
3277 kfree(tcon->nativeFileSystem);
3278 tcon->nativeFileSystem =
3279 kzalloc(length + 2, GFP_KERNEL);
3280 cifs_strfromUCS_le(tcon->nativeFileSystem,
3281 (__le16 *) bcc_ptr,
3282 length, nls_codepage);
3283 bcc_ptr += 2 * length;
3284 bcc_ptr[0] = 0; /* null terminate the string */
3285 bcc_ptr[1] = 0;
3286 bcc_ptr += 2;
3287 }
3288 /* else do not bother copying these informational fields */
3289 } else {
3290 length = strnlen(bcc_ptr, 1024);
3291 if ((bcc_ptr + length) -
3292 pByteArea(smb_buffer_response) <=
3293 BCC(smb_buffer_response)) {
3294 kfree(tcon->nativeFileSystem);
3295 tcon->nativeFileSystem =
3296 kzalloc(length + 1, GFP_KERNEL);
3297 strncpy(tcon->nativeFileSystem, bcc_ptr,
3298 length);
3299 }
3300 /* else do not bother copying these informational fields */
3301 }
3302 if((smb_buffer_response->WordCount == 3) ||
3303 (smb_buffer_response->WordCount == 7))
3304 /* field is in same location */
3305 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3306 else
3307 tcon->Flags = 0;
3308 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
3309 } else if ((rc == 0) && tcon == NULL) {
3310 /* all we need to save for IPC$ connection */
3311 ses->ipc_tid = smb_buffer_response->Tid;
3312 }
3313
3314 if (smb_buffer)
3315 cifs_buf_release(smb_buffer);
3316 return rc;
3317 }
3318
3319 int
3320 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3321 {
3322 int rc = 0;
3323 int xid;
3324 struct cifsSesInfo *ses = NULL;
3325 struct task_struct *cifsd_task;
3326 char * tmp;
3327
3328 xid = GetXid();
3329
3330 if (cifs_sb->tcon) {
3331 ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
3332 rc = CIFSSMBTDis(xid, cifs_sb->tcon);
3333 if (rc == -EBUSY) {
3334 FreeXid(xid);
3335 return 0;
3336 }
3337 tconInfoFree(cifs_sb->tcon);
3338 if ((ses) && (ses->server)) {
3339 /* save off task so we do not refer to ses later */
3340 cifsd_task = ses->server->tsk;
3341 cFYI(1, ("About to do SMBLogoff "));
3342 rc = CIFSSMBLogoff(xid, ses);
3343 if (rc == -EBUSY) {
3344 FreeXid(xid);
3345 return 0;
3346 } else if (rc == -ESHUTDOWN) {
3347 cFYI(1,("Waking up socket by sending it signal"));
3348 if (cifsd_task) {
3349 send_sig(SIGKILL,cifsd_task,1);
3350 kthread_stop(cifsd_task);
3351 }
3352 rc = 0;
3353 } /* else - we have an smb session
3354 left on this socket do not kill cifsd */
3355 } else
3356 cFYI(1, ("No session or bad tcon"));
3357 }
3358
3359 cifs_sb->tcon = NULL;
3360 tmp = cifs_sb->prepath;
3361 cifs_sb->prepathlen = 0;
3362 cifs_sb->prepath = NULL;
3363 kfree(tmp);
3364 if (ses)
3365 schedule_timeout_interruptible(msecs_to_jiffies(500));
3366 if (ses)
3367 sesInfoFree(ses);
3368
3369 FreeXid(xid);
3370 return rc; /* BB check if we should always return zero here */
3371 }
3372
3373 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
3374 struct nls_table * nls_info)
3375 {
3376 int rc = 0;
3377 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
3378 int ntlmv2_flag = FALSE;
3379 int first_time = 0;
3380
3381 /* what if server changes its buffer size after dropping the session? */
3382 if(pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
3383 rc = CIFSSMBNegotiate(xid, pSesInfo);
3384 if(rc == -EAGAIN) /* retry only once on 1st time connection */ {
3385 rc = CIFSSMBNegotiate(xid, pSesInfo);
3386 if(rc == -EAGAIN)
3387 rc = -EHOSTDOWN;
3388 }
3389 if(rc == 0) {
3390 spin_lock(&GlobalMid_Lock);
3391 if(pSesInfo->server->tcpStatus != CifsExiting)
3392 pSesInfo->server->tcpStatus = CifsGood;
3393 else
3394 rc = -EHOSTDOWN;
3395 spin_unlock(&GlobalMid_Lock);
3396
3397 }
3398 first_time = 1;
3399 }
3400 if (!rc) {
3401 pSesInfo->flags = 0;
3402 pSesInfo->capabilities = pSesInfo->server->capabilities;
3403 if(linuxExtEnabled == 0)
3404 pSesInfo->capabilities &= (~CAP_UNIX);
3405 /* pSesInfo->sequence_number = 0;*/
3406 cFYI(1,("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3407 pSesInfo->server->secMode,
3408 pSesInfo->server->capabilities,
3409 pSesInfo->server->timeAdj));
3410 if(experimEnabled < 2)
3411 rc = CIFS_SessSetup(xid, pSesInfo,
3412 first_time, nls_info);
3413 else if (extended_security
3414 && (pSesInfo->capabilities
3415 & CAP_EXTENDED_SECURITY)
3416 && (pSesInfo->server->secType == NTLMSSP)) {
3417 rc = -EOPNOTSUPP;
3418 } else if (extended_security
3419 && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
3420 && (pSesInfo->server->secType == RawNTLMSSP)) {
3421 cFYI(1, ("NTLMSSP sesssetup"));
3422 rc = CIFSNTLMSSPNegotiateSessSetup(xid,
3423 pSesInfo,
3424 &ntlmv2_flag,
3425 nls_info);
3426 if (!rc) {
3427 if(ntlmv2_flag) {
3428 char * v2_response;
3429 cFYI(1,("more secure NTLM ver2 hash"));
3430 if(CalcNTLMv2_partial_mac_key(pSesInfo,
3431 nls_info)) {
3432 rc = -ENOMEM;
3433 goto ss_err_exit;
3434 } else
3435 v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
3436 if(v2_response) {
3437 CalcNTLMv2_response(pSesInfo,v2_response);
3438 /* if(first_time)
3439 cifs_calculate_ntlmv2_mac_key(
3440 pSesInfo->server->mac_signing_key,
3441 response, ntlm_session_key, */
3442 kfree(v2_response);
3443 /* BB Put dummy sig in SessSetup PDU? */
3444 } else {
3445 rc = -ENOMEM;
3446 goto ss_err_exit;
3447 }
3448
3449 } else {
3450 SMBNTencrypt(pSesInfo->password,
3451 pSesInfo->server->cryptKey,
3452 ntlm_session_key);
3453
3454 if(first_time)
3455 cifs_calculate_mac_key(
3456 pSesInfo->server->mac_signing_key,
3457 ntlm_session_key,
3458 pSesInfo->password);
3459 }
3460 /* for better security the weaker lanman hash not sent
3461 in AuthSessSetup so we no longer calculate it */
3462
3463 rc = CIFSNTLMSSPAuthSessSetup(xid,
3464 pSesInfo,
3465 ntlm_session_key,
3466 ntlmv2_flag,
3467 nls_info);
3468 }
3469 } else { /* old style NTLM 0.12 session setup */
3470 SMBNTencrypt(pSesInfo->password,
3471 pSesInfo->server->cryptKey,
3472 ntlm_session_key);
3473
3474 if(first_time)
3475 cifs_calculate_mac_key(
3476 pSesInfo->server->mac_signing_key,
3477 ntlm_session_key, pSesInfo->password);
3478
3479 rc = CIFSSessSetup(xid, pSesInfo,
3480 ntlm_session_key, nls_info);
3481 }
3482 if (rc) {
3483 cERROR(1,("Send error in SessSetup = %d",rc));
3484 } else {
3485 cFYI(1,("CIFS Session Established successfully"));
3486 pSesInfo->status = CifsGood;
3487 }
3488 }
3489 ss_err_exit:
3490 return rc;
3491 }
3492
kmemtrace - Kernel memory tracer