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