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