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