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