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