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