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