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